Version: 9.16.0
SMESH_Meshio.h
Go to the documentation of this file.
1// Copyright (C) 2007-2026 CEA, EDF, OPEN CASCADE
2//
3// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
5//
6// This library is free software; you can redistribute it and/or
7// modify it under the terms of the GNU Lesser General Public
8// License as published by the Free Software Foundation; either
9// version 2.1 of the License, or (at your option) any later version.
10//
11// This library is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14// Lesser General Public License for more details.
15//
16// You should have received a copy of the GNU Lesser General Public
17// License along with this library; if not, write to the Free Software
18// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19//
20// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
21//
22
23// SMESH SMESH_I : support of import / export with meshio library
24// File : SMESH_Meshio.h
25// Author : Konstantin Leontev, Open CASCADE S.A.S.
26//
27#ifndef SMESH_MESHIO_H
28#define SMESH_MESHIO_H
29
30#include "SMESH.hxx"
31
32#include <QString>
33#include <QStringList>
34
35#include <map>
36#include <vector>
37#include <cstring>
38
39namespace SMESHIOConverter {
40
41 // Enum representing supported external converters
42 enum class ExternalConverter {
43 Gmsh,
44 MeshIo,
45 Unknown
46 };
47
48 // Convert enum -> String
49 inline std::string toString(ExternalConverter conv) noexcept {
50 switch (conv) {
51 case ExternalConverter::Gmsh: return "gmsh";
52 case ExternalConverter::MeshIo: return "meshio";
53 }
54 return "unknown";
55 }
56
57 // Enum representing supported mesh formats
58 enum class Extension {
59 // Gmsh1,
60 // Gmsh2,
61 Gmsh,
62 Gmsh41,
63 Gmsh41Binary,
64 Gmsh22,
65 Gmsh22Binary,
66 // Gmsh3,
67 // Gmsh4,
68 // Gmsh40,
69
70 Abaqus,
71 Ansys,
72 AvsUcd,
73 // Cgns,
74 DolfinXml,
75 ExodusE,
76 ExodusExo,
77 Flac3d,
78 H5m,
79 Kratos,
80 Mail,
81 // Med,
82 // MeditMesh,
83 // MeditMeshb,
84 NastranBdf,
85 NastranFem,
86 NastranNas,
87 NetgenVol,
88 NetgenVolGz,
89 Obj,
90 Off,
91 PermasDato,
92 PermasDatoGz,
93 PermasPost,
94 PermasPostGz,
95 Ply,
96 // Stl,
97 Su2,
98 Svg,
99 Tecplot,
100 TetgenEle,
101 TetgenNode,
102 Vtk,
103 Vtu,
104 Wkt,
105 XdmfXdmf,
106 XdmfXmf,
107 Ugrid,
108 Unknown,
109 };
110
111 // Structure storing metadata for each format
112 struct ExtensionInfo {
113 QString label; // label (e.g. "Gmsh 2.2 (*.msh)")
114 QString extension; // Primary extension or conversion option (e.g. "msh41")
115 std::map<ExternalConverter, QString> converters; // Map of converter -> option string (e.g. {{Gmsh,"msh"}, {MeshIo,"msh"}})
116 };
117
129 static const std::map<Extension, ExtensionInfo> ExtensionMap = {
130 // Gmsh-specific formats
131 // { Extension::Gmsh1, { "Gmsh 1 (*.msh)", "msh", { {ExternalConverter::Gmsh, "msh1"}, {ExternalConverter::MeshIo, "gmsh1"} } } },
132 // { Extension::Gmsh2, { "Gmsh 2 (*.msh)", "msh", { {ExternalConverter::Gmsh, "msh2"}, {ExternalConverter::MeshIo, "gmsh22"} } } },
133 { Extension::Gmsh, { "Gmsh (*.msh)", "msh", { {ExternalConverter::Gmsh, "msh"} } } },
134 { Extension::Gmsh22, { "Gmsh 2.2 (*.msh)", "msh", { {ExternalConverter::Gmsh, "msh22"} } } },
135 { Extension::Gmsh22Binary, { "Gmsh 2.2 binary (*.msh)", "msh", { {ExternalConverter::Gmsh, "msh22"} } } },
136 // { Extension::Gmsh3, { "Gmsh 3 (*.msh)", "msh", { {ExternalConverter::Gmsh, "msh3"} } } },
137 // { Extension::Gmsh40, { "Gmsh 4.0 (*.msh)", "msh", { {ExternalConverter::Gmsh, "msh40"}, {ExternalConverter::MeshIo, "gmsh40"} } } },
138 // { Extension::Gmsh4, { "Gmsh 4 (*.msh)", "msh", { {ExternalConverter::Gmsh, "msh4"} } } },
139 { Extension::Gmsh41, { "Gmsh 4.1 (*.msh)", "msh", { {ExternalConverter::Gmsh, "msh41"}, {ExternalConverter::MeshIo, "gmsh"} } } },
140 { Extension::Gmsh41Binary, { "Gmsh 4.1 binary (*.msh)", "msh", { {ExternalConverter::Gmsh, "msh41"}, {ExternalConverter::MeshIo, "gmsh"} } } },
141
142 { Extension::Mail, { "MAIL (*.mail)", "mail", { {ExternalConverter::Gmsh, "mail"} } } },
143 { Extension::Abaqus, { "Abaqus (*.inp)", "inp", { {ExternalConverter::Gmsh, "inp"} } } },
144 // { Extension::Cgns, { "CGNS (*.cgns)", "cgns", { {ExternalConverter::Gmsh, "cgns"} } } },
145 // { Extension::Med, { "MED/Salome (*.med)", "med", { {ExternalConverter::Gmsh, "med"} } } },
146 // { Extension::MeditMesh, { "Medit MESH (*.mesh)", "mesh", { {ExternalConverter::Gmsh, "mesh"} } } },
147 { Extension::NastranBdf, { "Nastran (*.bdf)", "bdf", { {ExternalConverter::Gmsh, "bdf"} } } },
148 { Extension::Obj, { "OBJ (*.obj)", "obj", { {ExternalConverter::Gmsh, "obj"} } } },
149 { Extension::Off, { "OFF (*.off)", "off", { {ExternalConverter::Gmsh, "off"} } } },
150 { Extension::Ply, { "PLY (*.ply)", "ply", { {ExternalConverter::Gmsh, "ply2"} } } },
151 // { Extension::Stl, { "STL (*.stl)", "stl", { {ExternalConverter::Gmsh, "stl"} } } },
152 { Extension::Su2, { "SU2 (*.su2)", "su2", { {ExternalConverter::Gmsh, "su2"} } } },
153 { Extension::Tecplot, { "Tecplot (*.tec)", "tec", { {ExternalConverter::Gmsh, "tec"} } } },
154 { Extension::Vtk, { "VTK (*.vtk)", "vtk", { {ExternalConverter::Gmsh, "vtk"} } } },
155
156 // MeshIo-specific formats
157 { Extension::Ansys, { "ANSYS msh (*.msh)", "ansys", { {ExternalConverter::MeshIo, "ansys"} } } },
158 { Extension::AvsUcd, { "AVS-UCD (*.avs)", "avs", { {ExternalConverter::MeshIo, "avsucd"} } } },
159 { Extension::DolfinXml, { "DOLFIN XML (*.xml)", "xml", { {ExternalConverter::MeshIo, "dolfin-xml"} } } },
160#if !defined(WIN32)
161 { Extension::ExodusE, { "Exodus (*.e)", "e", { {ExternalConverter::MeshIo, "exodus"} } } },
162 { Extension::ExodusExo, { "Exodus (*.exo)", "exo", { {ExternalConverter::MeshIo, "exodus"} } } },
163#endif
164 { Extension::Flac3d, { "FLAC3D (*.f3grid)", "f3grid", { {ExternalConverter::MeshIo, "flac3d"} } } },
165 { Extension::H5m, { "H5M (*.h5m)", "h5m", { {ExternalConverter::MeshIo, "h5m"} } } },
166 { Extension::Kratos, { "Kratos/MDPA (*.mdpa)", "mdpa", { {ExternalConverter::MeshIo, "mdpa"} } } },
167 // { Extension::MeditMeshb, { "Medit MESHB (*.meshb)", "meshb", { {ExternalConverter::MeshIo, "medit"} } } },
168 { Extension::NastranFem, { "Nastran (*.fem)", "fem", { {ExternalConverter::MeshIo, "nastran"} } } },
169 { Extension::NastranNas, { "Nastran (*.nas)", "nas", { {ExternalConverter::MeshIo, "nastran"} } } },
170 { Extension::NetgenVol, { "Netgen (*.vol)", "vol", { {ExternalConverter::MeshIo, "netgen"} } } },
171 { Extension::NetgenVolGz, { "Netgen (*.vol.gz)", "vol.gz", { {ExternalConverter::MeshIo, "netgen"} } } },
172 { Extension::PermasPost, { "PERMAS (*.post)", "post", { {ExternalConverter::MeshIo, "permas"} } } },
173 { Extension::PermasPostGz, { "PERMAS (*.post.gz)", "post.gz", { {ExternalConverter::MeshIo, "permas"} } } },
174 { Extension::PermasDato, { "PERMAS (*.dato)", "dato", { {ExternalConverter::MeshIo, "permas"} } } },
175 { Extension::PermasDatoGz, { "PERMAS (*.dato.gz)", "dato.gz", { {ExternalConverter::MeshIo, "permas"} } } },
176 { Extension::Svg, { "SVG, 2D output only (*.svg)", "svg", { {ExternalConverter::MeshIo, "svg"} } } },
177 { Extension::TetgenNode, { "TetGen (*.node)", "node", { {ExternalConverter::MeshIo, "tetgen"} } } },
178 { Extension::TetgenEle, { "TetGen (*.ele)", "ele", { {ExternalConverter::MeshIo, "tetgen"} } } },
179 { Extension::Ugrid, { "UGRID (*.ugrid)", "ugrid", { {ExternalConverter::MeshIo, "ugrid"} } } },
180 { Extension::Vtu, { "VTU (*.vtu)", "vtu", { {ExternalConverter::MeshIo, "vtu"} } } },
181 { Extension::Wkt, { "WKT, TIN (*.wkt)", "wkt", { {ExternalConverter::MeshIo, "wkt"} } } },
182 { Extension::XdmfXdmf, { "XDMF (*.xdmf)", "xdmf", { {ExternalConverter::MeshIo, "xdmf"} } } },
183 { Extension::XdmfXmf, { "XDMF (*.xmf)", "xmf", { {ExternalConverter::MeshIo, "xdmf"} } } },
184 };
185
186 // convert label -> label without extension part in brackets (e.g. "Gmsh 2.2" from "Gmsh 2.2 (*.msh)")
187 inline std::string GetFilterLabel(const QString& filter) {
188 const QStringList parts = filter.split('(');
189 if (!parts.isEmpty()) {
190 return parts[0].trimmed().toStdString();
191 }
192 return filter.toStdString();
193 }
194
195 // Convert enum -> label
196 inline QString toLabel(Extension fmt) {
197 auto it = ExtensionMap.find(fmt);
198 return (it != ExtensionMap.end()) ? it->second.label : "Unknown";
199 }
200
201 // Convert enum -> extension
202 inline QString toExtension(Extension fmt) {
203 auto it = ExtensionMap.find(fmt);
204 return (it != ExtensionMap.end()) ? it->second.extension : "";
205 }
206
207 // Get the converter-specific option string for a format
208 inline QString toOption(Extension fmt, ExternalConverter conv) {
209 auto it = ExtensionMap.find(fmt);
210 if (it != ExtensionMap.end()) {
211 auto convIt = it->second.converters.find(conv);
212 if (convIt != it->second.converters.end())
213 return convIt->second;
214 }
215 return "Unknown"; // fallback if converter not found
216 }
217
218 // Convert label -> enum
219 inline Extension fromLabel(const QString& label) {
220 for (const auto& [fmt, info] : ExtensionMap) {
221 if (GetFilterLabel(info.label) == GetFilterLabel(label))
222 return fmt;
223 }
224 return Extension::Unknown;
225 }
226
227 // Convert extension -> enum
228 inline Extension fromExtension(const QString& ext) {
229 for (const auto& [fmt, info] : ExtensionMap) {
230 if (info.extension.compare(ext, Qt::CaseInsensitive) == 0)
231 return fmt;
232 }
233 return Extension::Unknown;
234 }
235
236 // Convert option string -> enum (converter-specific)
237 inline Extension fromOption(const QString& opt, ExternalConverter conv) {
238 for (const auto& [fmt, info] : ExtensionMap) {
239 auto convIt = info.converters.find(conv);
240 if (convIt != info.converters.end() &&
241 convIt->second.compare(opt, Qt::CaseInsensitive) == 0)
242 return fmt;
243 }
244 return Extension::Unknown;
245 }
246
247} // namespace SMESHIOConverter
248
249class SMESH_I_EXPORT SMESH_Meshio
250{
251public:
252 SMESH_Meshio();
253 SMESH_Meshio(const QString& selectedFilter);
254 virtual ~SMESH_Meshio();
255
256 QString CreateTempFileName(const QString& targetFileName);
257 void Convert(const QString& sourceFileName, const QString& targetFileName, bool isImport = false, const QString& converter = QString()) const;
258
259 static QString GetMeshioVersion();
260 static bool IsModernMeshioVersion();
261 static bool IsMeshioInstalled();
262 static bool IsModernPythonVersion();
263
264 static QString GetConverterVersion(SMESHIOConverter::ExternalConverter converter);
265 static bool IsConverterInstalled(SMESHIOConverter::ExternalConverter converter = SMESHIOConverter::ExternalConverter::Gmsh);
266 static SMESHIOConverter::ExternalConverter GetConverterForExtension(const QString& selectedFilter = QString(), const QString& sourceFileName = QString(), const QString& converter = QString());
267
268
269private:
270 void RemoveTempFile();
271 void CreateErrorFileName();
272 void RemoveErrorFile();
273 std::string ReadErrorsFromFile() const;
274
275 QString GetConvertOptArgs(SMESHIOConverter::ExternalConverter externalConverter, const QString& sourceFileName = QString()) const;
276
277
278private:
279 QString myTempFileName;
280 QString myErrorFileName;
281 QString mySelectedFilter;
282};
283
284#endif // SMESH_MESHIO_H
SMESH_I_EXPORT
#define SMESH_I_EXPORT
Definition: SMESH.hxx:39
SMESH_Meshio
Definition: SMESH_Meshio.h:250
SMESH_Meshio::myTempFileName
QString myTempFileName
Definition: SMESH_Meshio.h:279
SMESH_Meshio::myErrorFileName
QString myErrorFileName
Definition: SMESH_Meshio.h:280
SMESH_Meshio::mySelectedFilter
QString mySelectedFilter
Definition: SMESH_Meshio.h:281
SMESHIOConverter
Definition: SMESH_Meshio.h:39
SMESHIOConverter::GetFilterLabel
std::string GetFilterLabel(const QString &filter)
Definition: SMESH_Meshio.h:187
SMESHIOConverter::Extension
Extension
Definition: SMESH_Meshio.h:58
SMESHIOConverter::toOption
QString toOption(Extension fmt, ExternalConverter conv)
Definition: SMESH_Meshio.h:208
SMESHIOConverter::fromLabel
Extension fromLabel(const QString &label)
Definition: SMESH_Meshio.h:219
SMESHIOConverter::toLabel
QString toLabel(Extension fmt)
Definition: SMESH_Meshio.h:196
SMESHIOConverter::ExtensionMap
static const std::map< Extension, ExtensionInfo > ExtensionMap
Mapping table between each mesh format (Extension) and its metadata.
Definition: SMESH_Meshio.h:129
SMESHIOConverter::toExtension
QString toExtension(Extension fmt)
Definition: SMESH_Meshio.h:202
SMESHIOConverter::toString
std::string toString(ExternalConverter conv) noexcept
Definition: SMESH_Meshio.h:49
SMESHIOConverter::fromOption
Extension fromOption(const QString &opt, ExternalConverter conv)
Definition: SMESH_Meshio.h:237
SMESHIOConverter::ExternalConverter
ExternalConverter
Definition: SMESH_Meshio.h:42
SMESHIOConverter::fromExtension
Extension fromExtension(const QString &ext)
Definition: SMESH_Meshio.h:228
SMESHIOConverter::ExtensionInfo
Definition: SMESH_Meshio.h:112
SMESHIOConverter::ExtensionInfo::label
QString label
Definition: SMESH_Meshio.h:113
SMESHIOConverter::ExtensionInfo::extension
QString extension
Definition: SMESH_Meshio.h:114
SMESHIOConverter::ExtensionInfo::converters
std::map< ExternalConverter, QString > converters
Definition: SMESH_Meshio.h:115