applications/utilities/surface/surfaceMeshExport/surfaceMeshExport.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     surfaceMeshExport
  26
  27 Description
  28     Export from surfMesh to various third-party surface formats with
  29     optional scaling or transformations (rotate/translate) on a
  30     coordinateSystem.
  31
  32 Usage
  33     - surfaceMeshExport outputFile [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         "export from surfMesh to various third-party surface formats"
  78     );
  79
  80     argList::noParallel();
  81     argList::validArgs.append("outputFile");
  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 reading - "
  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 the source coordinate system, applied after '-scaleIn'"
 118     );
 119     argList::addOption
 120     (
 121         "to",
 122         "coordinateSystem",
 123         "specify the target coordinate system, applied before '-scaleOut'"
 124     );
 125
 126     argList args(argc, argv);
 127     Time runTime(args.rootPath(), args.caseName());
 128
 129     const fileName exportName = args[1];
 130     const word importName = args.optionLookupOrDefault<word>("name", "default");
 131
 132     // check that writing is supported
 133     if (!MeshedSurface<face>::canWriteType(exportName.ext(), true))
 134     {
 135         return 1;
 136     }
 137
 138
 139     // get the coordinate transformations
 140     autoPtr<coordinateSystem> fromCsys;
 141     autoPtr<coordinateSystem> toCsys;
 142
 143     if (args.optionFound("from") || args.optionFound("to"))
 144     {
 145         autoPtr<IOobject> ioPtr;
 146
 147         if (args.optionFound("dict"))
 148         {
 149             const fileName dictPath = args["dict"];
 150
 151             ioPtr.set
 152             (
 153                 new IOobject
 154                 (
 155                     (
 156                         isDir(dictPath)
 157                       ? dictPath/coordinateSystems::typeName
 158                       : dictPath
 159                     ),
 160                     runTime,
 161                     IOobject::MUST_READ,
 162                     IOobject::NO_WRITE,
 163                     false
 164                 )
 165             );
 166         }
 167         else
 168         {
 169             ioPtr.set
 170             (
 171                 new IOobject
 172                 (
 173                     coordinateSystems::typeName,
 174                     runTime.constant(),
 175                     runTime,
 176                     IOobject::MUST_READ,
 177                     IOobject::NO_WRITE,
 178                     false
 179                 )
 180             );
 181         }
 182
 183
 184         if (!ioPtr->headerOk())
 185         {
 186             FatalErrorIn(args.executable())
 187                 << "Cannot open coordinateSystems file\n    "
 188                 << ioPtr->objectPath() << nl
 189                 << exit(FatalError);
 190         }
 191
 192         coordinateSystems csLst(ioPtr());
 193
 194         if (args.optionFound("from"))
 195         {
 196             const word csName = args["from"];
 197
 198             const label csIndex = csLst.findIndex(csName);
 199             if (csIndex < 0)
 200             {
 201                 FatalErrorIn(args.executable())
 202                     << "Cannot find -from " << csName << nl
 203                     << "available coordinateSystems: " << csLst.toc() << nl
 204                     << exit(FatalError);
 205             }
 206
 207             fromCsys.reset(new coordinateSystem(csLst[csIndex]));
 208         }
 209
 210         if (args.optionFound("to"))
 211         {
 212             const word csName = args["to"];
 213
 214             const label csIndex = csLst.findIndex(csName);
 215             if (csIndex < 0)
 216             {
 217                 FatalErrorIn(args.executable())
 218                     << "Cannot find -to " << csName << nl
 219                     << "available coordinateSystems: " << csLst.toc() << nl
 220                     << exit(FatalError);
 221             }
 222
 223             toCsys.reset(new coordinateSystem(csLst[csIndex]));
 224         }
 225
 226
 227         // maybe fix this later
 228         if (fromCsys.valid() && toCsys.valid())
 229         {
 230             FatalErrorIn(args.executable())
 231                 << "Only allowed  '-from' or '-to' option at the moment."
 232                 << exit(FatalError);
 233         }
 234     }
 235
 236
 237     surfMesh smesh
 238     (
 239         IOobject
 240         (
 241             importName,
 242             runTime.constant(),
 243             runTime,
 244             IOobject::MUST_READ_IF_MODIFIED,
 245             IOobject::NO_WRITE
 246         )
 247     );
 248
 249     Info<< "read surfMesh:\n  " << smesh.objectPath() << endl;
 250
 251
 252     // Simply copy for now, but really should have a separate write method
 253
 254     MeshedSurface<face> surf(smesh);
 255
 256     if (args.optionFound("clean"))
 257     {
 258         surf.cleanup(true);
 259     }
 260
 261     scalar scaleIn = 0;
 262     if (args.optionReadIfPresent("scaleIn", scaleIn) && scaleIn > 0)
 263     {
 264         Info<< " -scaleIn " << scaleIn << endl;
 265         surf.scalePoints(scaleIn);
 266     }
 267
 268     if (fromCsys.valid())
 269     {
 270         Info<< " -from " << fromCsys().name() << endl;
 271         tmp<pointField> tpf = fromCsys().localPosition(surf.points());
 272         surf.movePoints(tpf());
 273     }
 274
 275     if (toCsys.valid())
 276     {
 277         Info<< " -to " << toCsys().name() << endl;
 278         tmp<pointField> tpf = toCsys().globalPosition(surf.points());
 279         surf.movePoints(tpf());
 280     }
 281
 282     scalar scaleOut = 0;
 283     if (args.optionReadIfPresent("scaleOut", scaleOut) && scaleOut > 0)
 284     {
 285         Info<< " -scaleOut " << scaleOut << endl;
 286         surf.scalePoints(scaleOut);
 287     }
 288
 289
 290     surf.writeStats(Info);
 291     Info<< endl;
 292
 293     Info<< "writing " << exportName << endl;
 294     surf.write(exportName);
 295
 296     Info<< "\nEnd\n" << endl;
 297
 298     return 0;
 299 }
 300
 301 // ************************************************************************* //