applications/utilities/surface/surfaceMeshImport/surfaceMeshImport.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 Application
  25     surfaceMeshImport
  26
  27 Description
  28     Import from various third-party surface formats into surfMesh
  29     with optional scaling or transformations (rotate/translate)
  30     on a coordinateSystem.
  31
  32 Usage
  33     - surfaceMeshImport inputFile [OPTION]
  34
  35     \param -clean \n
  36     Perform some surface checking/cleanup on the input surface.
  37
  38     \param -name \<name\> \n
  39     Specify an alternative surface name when writing.
  40
  41     \param -scaleIn \<scale\> \n
  42     Specify a scaling factor when reading files.
  43
  44     \param -scaleOut \<scale\> \n
  45     Specify a scaling factor when writing files.
  46
  47     \param -dict \<dictionary\> \n
  48     Specify an alternative dictionary for constant/coordinateSystems.
  49
  50     \param -from \<coordinateSystem\> \n
  51     Specify a coordinate system when reading files.
  52
  53     \param -to \<coordinateSystem\> \n
  54     Specify a coordinate system when writing files.
  55
  56 Note
  57     The filename extensions are used to determine the file format type.
  58
  59 \*---------------------------------------------------------------------------*/
  60
  61 #include "argList.H"
  62 #include "timeSelector.H"
  63 #include "Time.H"
  64
  65 #include "MeshedSurfaces.H"
  66 #include "coordinateSystems.H"
  67
  68 using namespace Foam;
  69
  70 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  71 //  Main program:
  72
  73 int main(int argc, char *argv[])
  74 {
  75     argList::addNote
  76     (
  77         "import from various third-party surface formats into surfMesh"
  78     );
  79
  80     argList::noParallel();
  81     argList::validArgs.append("inputFile");
  82
  83     argList::addBoolOption
  84     (
  85         "clean",
  86         "perform some surface checking/cleanup on the input surface"
  87     );
  88     argList::addOption
  89     (
  90         "name",
  91         "name",
  92         "specify an alternative surface name when writing - "
  93         "default is 'default'"
  94     );
  95     argList::addOption
  96     (
  97         "scaleIn",
  98         "factor",
  99         "geometry scaling factor on input - default is 1"
 100     );
 101     argList::addOption
 102     (
 103         "scaleOut",
 104         "factor",
 105         "geometry scaling factor on output - default is 1"
 106     );
 107     argList::addOption
 108     (
 109         "dict",
 110         "file",
 111         "specify an alternative dictionary for constant/coordinateSystems"
 112     );
 113     argList::addOption
 114     (
 115         "from",
 116         "coordinateSystem",
 117         "specify a local coordinate system when reading files."
 118     );
 119     argList::addOption
 120     (
 121         "to",
 122         "coordinateSystem",
 123         "specify a local coordinate system when writing files."
 124     );
 125
 126     #include "setRootCase.H"
 127     #include "createTime.H"
 128
 129     // try for the latestTime, but create "constant" as needed
 130     instantList Times = runTime.times();
 131     if (Times.size())
 132     {
 133         label startTime = Times.size()-1;
 134         runTime.setTime(Times[startTime], startTime);
 135     }
 136     else
 137     {
 138         runTime.setTime(instant(0, runTime.constant()), 0);
 139     }
 140
 141
 142     const fileName importName = args[1];
 143     const word exportName = args.optionLookupOrDefault<word>("name", "default");
 144
 145     // check that reading is supported
 146     if (!MeshedSurface<face>::canRead(importName, true))
 147     {
 148         return 1;
 149     }
 150
 151
 152     // get the coordinate transformations
 153     autoPtr<coordinateSystem> fromCsys;
 154     autoPtr<coordinateSystem> toCsys;
 155
 156     if (args.optionFound("from") || args.optionFound("to"))
 157     {
 158         autoPtr<IOobject> ioPtr;
 159
 160         if (args.optionFound("dict"))
 161         {
 162             const fileName dictPath = args["dict"];
 163
 164             ioPtr.set
 165             (
 166                 new IOobject
 167                 (
 168                     (
 169                         isDir(dictPath)
 170                       ? dictPath/coordinateSystems::typeName
 171                       : dictPath
 172                     ),
 173                     runTime,
 174                     IOobject::MUST_READ,
 175                     IOobject::NO_WRITE,
 176                     false
 177                 )
 178             );
 179         }
 180         else
 181         {
 182             ioPtr.set
 183             (
 184                 new IOobject
 185                 (
 186                     coordinateSystems::typeName,
 187                     runTime.constant(),
 188                     runTime,
 189                     IOobject::MUST_READ,
 190                     IOobject::NO_WRITE,
 191                     false
 192                 )
 193             );
 194         }
 195
 196
 197         if (!ioPtr->headerOk())
 198         {
 199             FatalErrorIn(args.executable())
 200                 << "Cannot open coordinateSystems file\n    "
 201                 << ioPtr->objectPath() << nl
 202                 << exit(FatalError);
 203         }
 204
 205         coordinateSystems csLst(ioPtr());
 206
 207         if (args.optionFound("from"))
 208         {
 209             const word csName = args["from"];
 210
 211             const label csIndex = csLst.findIndex(csName);
 212             if (csIndex < 0)
 213             {
 214                 FatalErrorIn(args.executable())
 215                     << "Cannot find -from " << csName << nl
 216                     << "available coordinateSystems: " << csLst.toc() << nl
 217                     << exit(FatalError);
 218             }
 219
 220             fromCsys.reset(new coordinateSystem(csLst[csIndex]));
 221         }
 222
 223         if (args.optionFound("to"))
 224         {
 225             const word csName = args["to"];
 226
 227             const label csIndex = csLst.findIndex(csName);
 228             if (csIndex < 0)
 229             {
 230                 FatalErrorIn(args.executable())
 231                     << "Cannot find -to " << csName << nl
 232                     << "available coordinateSystems: " << csLst.toc() << nl
 233                     << exit(FatalError);
 234             }
 235
 236             toCsys.reset(new coordinateSystem(csLst[csIndex]));
 237         }
 238
 239
 240         // maybe fix this later
 241         if (fromCsys.valid() && toCsys.valid())
 242         {
 243             FatalErrorIn(args.executable())
 244                 << "Only allowed  '-from' or '-to' option at the moment."
 245                 << exit(FatalError);
 246         }
 247     }
 248
 249
 250
 251     MeshedSurface<face> surf(importName);
 252
 253     if (args.optionFound("clean"))
 254     {
 255         surf.cleanup(true);
 256     }
 257
 258
 259     scalar scaleIn = 0;
 260     if (args.optionReadIfPresent("scaleIn", scaleIn) && scaleIn > 0)
 261     {
 262         Info<< " -scaleIn " << scaleIn << endl;
 263         surf.scalePoints(scaleIn);
 264     }
 265
 266     if (fromCsys.valid())
 267     {
 268         Info<< " -from " << fromCsys().name() << endl;
 269         tmp<pointField> tpf = fromCsys().localPosition(surf.points());
 270         surf.movePoints(tpf());
 271     }
 272
 273     if (toCsys.valid())
 274     {
 275         Info<< " -to " << toCsys().name() << endl;
 276         tmp<pointField> tpf = toCsys().globalPosition(surf.points());
 277         surf.movePoints(tpf());
 278     }
 279
 280     scalar scaleOut = 0;
 281     if (args.optionReadIfPresent("scaleOut", scaleOut) && scaleOut > 0)
 282     {
 283         Info<< " -scaleOut " << scaleOut << endl;
 284         surf.scalePoints(scaleOut);
 285     }
 286
 287     surfMesh smesh
 288     (
 289         IOobject
 290         (
 291             exportName,
 292             runTime.constant(),
 293             runTime
 294         ),
 295         surf.xfer()
 296     );
 297
 298
 299     Info<< "writing surfMesh:\n  " << smesh.objectPath() << endl;
 300     smesh.write();
 301
 302     Info<< "\nEnd\n" << endl;
 303
 304     return 0;
 305 }
 306
 307 // ************************************************************************* //