applications/utilities/surface/surfaceTransformPoints/surfaceTransformPoints.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
   6      \\/     M anipulation  |
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of OpenFOAM.
  10
  11     OpenFOAM is free software: you can redistribute it and/or modify it
  12     under the terms of the GNU General Public License as published by
  13     the Free Software Foundation, either version 3 of the License, or
  14     (at your option) any later version.
  15
  16     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
  17     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  18     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  19     for more details.
  20
  21     You should have received a copy of the GNU General Public License
  22     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
  23
  24 Description
  25     Transform (scale/rotate) a surface.
  26     Like transformPoints but for surfaces.
  27
  28     The rollPitchYaw option takes three angles (degrees):
  29     - roll (rotation about x) followed by
  30     - pitch (rotation about y) followed by
  31     - yaw (rotation about z)
  32
  33     The yawPitchRoll does yaw followed by pitch followed by roll.
  34
  35 \*---------------------------------------------------------------------------*/
  36
  37 #include "argList.H"
  38 #include "OFstream.H"
  39 #include "IFstream.H"
  40 #include "boundBox.H"
  41 #include "transformField.H"
  42 #include "Pair.H"
  43 #include "quaternion.H"
  44 #include "mathematicalConstants.H"
  45
  46 #include "MeshedSurfaces.H"
  47
  48 using namespace Foam;
  49 using namespace Foam::constant::mathematical;
  50
  51
  52 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  53 // Main program:
  54
  55 int main(int argc, char *argv[])
  56 {
  57     argList::addNote
  58     (
  59         "Transform (scale/rotate) a surface. "
  60         "Like transformPoints but for surfaces."
  61     );
  62     argList::noParallel();
  63     argList::validArgs.append("surfaceFile");
  64     argList::validArgs.append("output surfaceFile");
  65     argList::addOption
  66     (
  67         "translate",
  68         "vector",
  69         "translate by the specified <vector> - eg, '(1 0 0)'"
  70     );
  71     argList::addOption
  72     (
  73         "rotate",
  74         "(vectorA vectorB)",
  75         "transform in terms of a rotation between <vectorA> and <vectorB> "
  76         "- eg, '( (1 0 0) (0 0 1) )'"
  77     );
  78     argList::addOption
  79     (
  80         "scale",
  81         "vector",
  82         "scale by the specified amount - eg, '(0.001 0.001 0.001)' for a "
  83         "uniform [mm] to [m] scaling"
  84     );
  85     argList::addOption
  86     (
  87         "rollPitchYaw",
  88         "vector",
  89         "transform in terms of '( roll pitch yaw )' in degrees"
  90     );
  91     argList::addOption
  92     (
  93         "yawPitchRoll",
  94         "vector",
  95         "transform in terms of '( yaw pitch roll )' in degrees"
  96     );
  97     argList args(argc, argv);
  98
  99     const fileName surfFileName = args[1];
 100     const fileName outFileName  = args[2];
 101
 102     Info<< "Reading surf from " << surfFileName << " ..." << nl
 103         << "Writing surf to " << outFileName << " ..." << endl;
 104
 105     if (args.options().empty())
 106     {
 107         FatalErrorIn(args.executable())
 108             << "No options supplied, please use one or more of "
 109                "-translate, -rotate or -scale options."
 110             << exit(FatalError);
 111     }
 112
 113     meshedSurface surf1(surfFileName);
 114
 115     pointField points(surf1.points());
 116
 117     vector v;
 118     if (args.optionReadIfPresent("translate", v))
 119     {
 120         Info<< "Translating points by " << v << endl;
 121
 122         points += v;
 123     }
 124
 125     if (args.optionFound("rotate"))
 126     {
 127         Pair<vector> n1n2
 128         (
 129             args.optionLookup("rotate")()
 130         );
 131         n1n2[0] /= mag(n1n2[0]);
 132         n1n2[1] /= mag(n1n2[1]);
 133
 134         tensor T = rotationTensor(n1n2[0], n1n2[1]);
 135
 136         Info<< "Rotating points by " << T << endl;
 137
 138         points = transform(T, points);
 139     }
 140     else if (args.optionReadIfPresent("rollPitchYaw", v))
 141     {
 142         Info<< "Rotating points by" << nl
 143             << "    roll  " << v.x() << nl
 144             << "    pitch " << v.y() << nl
 145             << "    yaw   " << v.z() << nl;
 146
 147         // Convert to radians
 148         v *= pi/180.0;
 149
 150         quaternion R(v.x(), v.y(), v.z());
 151
 152         Info<< "Rotating points by quaternion " << R << endl;
 153         points = transform(R, points);
 154     }
 155     else if (args.optionReadIfPresent("yawPitchRoll", v))
 156     {
 157         Info<< "Rotating points by" << nl
 158             << "    yaw   " << v.x() << nl
 159             << "    pitch " << v.y() << nl
 160             << "    roll  " << v.z() << nl;
 161
 162
 163         // Convert to radians
 164         v *= pi/180.0;
 165
 166         scalar yaw = v.x();
 167         scalar pitch = v.y();
 168         scalar roll = v.z();
 169
 170         quaternion R = quaternion(vector(0, 0, 1), yaw);
 171         R *= quaternion(vector(0, 1, 0), pitch);
 172         R *= quaternion(vector(1, 0, 0), roll);
 173
 174         Info<< "Rotating points by quaternion " << R << endl;
 175         points = transform(R, points);
 176     }
 177
 178     if (args.optionReadIfPresent("scale", v))
 179     {
 180         Info<< "Scaling points by " << v << endl;
 181
 182         points.replace(vector::X, v.x()*points.component(vector::X));
 183         points.replace(vector::Y, v.y()*points.component(vector::Y));
 184         points.replace(vector::Z, v.z()*points.component(vector::Z));
 185     }
 186
 187     surf1.movePoints(points);
 188     surf1.write(outFileName);
 189
 190     Info<< "End\n" << endl;
 191
 192     return 0;
 193 }
 194
 195
 196 // ************************************************************************* //