OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-04-05 18:16:23 +03:00
Code Packages Releases Activity

OCC22572 Support of progress indicator in RWStl and optimization of reading Ascii.

Browse Source
This commit is contained in:
RLN and KGV 2011-07-12 17:24:21 +00:00 committed by bugmaster
parent 3d166d310c
commit 9c6afe1912
3 changed files with 170 additions and 165 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
src/RWStl/RWStl.cdl
View File

@ -21,24 +21,28 @@ uses
OSD, OSD,
Standard, Standard,
StlMesh StlMesh,
Message
is is
WriteBinary (aMesh : Mesh from StlMesh; aPath : Path from OSD) WriteBinary (aMesh : Mesh from StlMesh; aPath : Path from OSD;
aProgInd : ProgressIndicator from Message = NULL)
returns Boolean from Standard; returns Boolean from Standard;
---Purpose : write the meshing in a file following the ---Purpose : write the meshing in a file following the
-- binary format of an STL file. -- binary format of an STL file.
-- Returns false if the cannot be opened; -- Returns false if the cannot be opened;
WriteAscii (aMesh : Mesh from StlMesh; aPath : Path from OSD) WriteAscii (aMesh : Mesh from StlMesh; aPath : Path from OSD;
aProgInd : ProgressIndicator from Message = NULL)
returns Boolean from Standard; returns Boolean from Standard;
---Purpose : write the meshing in a file following the ---Purpose : write the meshing in a file following the
-- Ascii format of an STL file. -- Ascii format of an STL file.
-- Returns false if the cannot be opened; -- Returns false if the cannot be opened;
ReadFile (aPath : Path from OSD) returns ReadFile (aPath : Path from OSD;
aProgInd : ProgressIndicator from Message = NULL) returns
Mesh from StlMesh; Mesh from StlMesh;
---Purpose : This method will chwck if the file is a binary ---Purpose : This method will chwck if the file is a binary
-- file or an AsciiFile testing the 5 first -- file or an AsciiFile testing the 5 first
@ -46,7 +50,8 @@ is
-- ascii file. If we do not find that word we assume -- ascii file. If we do not find that word we assume
-- that it is a binary file. -- that it is a binary file.
ReadBinary (aPath : Path from OSD) returns ReadBinary (aPath : Path from OSD;
aProgInd : ProgressIndicator from Message = NULL) returns
Mesh from StlMesh; Mesh from StlMesh;
---Purpose : Read a meshing from a binary file ---Purpose : Read a meshing from a binary file
-- Raises NoMoreObject from Standard if a statement -- Raises NoMoreObject from Standard if a statement
@ -54,7 +59,8 @@ is
-- Raises TypeMisMatch if a token has not the good -- Raises TypeMisMatch if a token has not the good
-- type (often real) -- type (often real)
ReadAscii (aPath : Path from OSD) returns ReadAscii (aPath : Path from OSD;
aProgInd : ProgressIndicator from Message = NULL) returns
Mesh from StlMesh; Mesh from StlMesh;
---Purpose : Read a meshing from a binary file ---Purpose : Read a meshing from a binary file
-- Raises NoMoreObject from Standard if a statement -- Raises NoMoreObject from Standard if a statement

229
src/RWStl/RWStl.cxx
View File

@ -8,6 +8,7 @@
#include <RWStl.ixx> #include <RWStl.ixx>
#include <OSD_Protection.hxx> #include <OSD_Protection.hxx>
#include <OSD_File.hxx> #include <OSD_File.hxx>
#include <Message_ProgressSentry.hxx>
#include <TCollection_AsciiString.hxx> #include <TCollection_AsciiString.hxx>
#include <Standard_NoMoreObject.hxx> #include <Standard_NoMoreObject.hxx>
#include <Standard_TypeMismatch.hxx> #include <Standard_TypeMismatch.hxx>
@ -26,6 +27,7 @@ static const int HEADER_SIZE = 84;
static const int SIZEOF_STL_FACET = 50; static const int SIZEOF_STL_FACET = 50;
static const int STL_MIN_FILE_SIZE = 284; static const int STL_MIN_FILE_SIZE = 284;
static const int ASCII_LINES_PER_FACET = 7; static const int ASCII_LINES_PER_FACET = 7;
static const int IND_THRESHOLD = 1000; // increment the indicator every 1k triangles
//======================================================================= //=======================================================================
//function : WriteInteger //function : WriteInteger
@ -108,94 +110,114 @@ inline static Standard_Real ReadFloat2Double(OSD_File &aFile)
//purpose : write a binary STL file in Little Endian format //purpose : write a binary STL file in Little Endian format
//======================================================================= //=======================================================================
Standard_Boolean RWStl::WriteBinary(const Handle(StlMesh_Mesh)& aMesh, const OSD_Path& aPath) Standard_Boolean RWStl::WriteBinary (const Handle(StlMesh_Mesh)& theMesh,
const OSD_Path& thePath,
const Handle(Message_ProgressIndicator)& theProgInd)
{ {
OSD_File aFile (thePath);
OSD_File theFile = OSD_File (aPath); aFile.Build (OSD_WriteOnly, OSD_Protection());
theFile.Build(OSD_WriteOnly,OSD_Protection());
Standard_Real x1, y1, z1; Standard_Real x1, y1, z1;
Standard_Real x2, y2, z2; Standard_Real x2, y2, z2;
Standard_Real x3, y3, z3; Standard_Real x3, y3, z3;
//pgo Standard_Real x,y,z; // writing 80 bytes of the trash?
char sval[80]; char sval[80];
Standard_Integer NBTRIANGLES=0; aFile.Write ((Standard_Address)sval,80);
unsigned int NBT; WriteInteger (aFile, theMesh->NbTriangles());
NBTRIANGLES = aMesh->NbTriangles();
NBT = NBTRIANGLES ;
theFile.Write ((Standard_Address)sval,80);
WriteInteger(theFile,NBT);
// theFile.Write ((Standard_Address)&NBT,4);
int dum=0; int dum=0;
StlMesh_MeshExplorer aMexp (aMesh); StlMesh_MeshExplorer aMexp (theMesh);
// create progress sentry for domains
for (Standard_Integer nbd=1;nbd<=aMesh->NbDomains();nbd++) { Standard_Integer aNbDomains = theMesh->NbDomains();
for (aMexp.InitTriangle (nbd); aMexp.MoreTriangle (); aMexp.NextTriangle ()) { Message_ProgressSentry aDPS (theProgInd, "Mesh domains", 0, aNbDomains, 1);
for (Standard_Integer nbd = 1; nbd <= aNbDomains && aDPS.More(); nbd++, aDPS.Next())
{
// create progress sentry for triangles in domain
Message_ProgressSentry aTPS (theProgInd, "Triangles", 0,
theMesh->NbTriangles (nbd), IND_THRESHOLD);
Standard_Integer aTriangleInd = 0;
for (aMexp.InitTriangle (nbd); aMexp.MoreTriangle(); aMexp.NextTriangle())
{
aMexp.TriangleVertices (x1,y1,z1,x2,y2,z2,x3,y3,z3); aMexp.TriangleVertices (x1,y1,z1,x2,y2,z2,x3,y3,z3);
//pgo aMexp.TriangleOrientation (x,y,z); //pgo aMexp.TriangleOrientation (x,y,z);
gp_XYZ Vect12 ((x2-x1), (y2-y1), (z2-z1)); gp_XYZ Vect12 ((x2-x1), (y2-y1), (z2-z1));
gp_XYZ Vect13 ((x3-x1), (y3-y1), (z3-z1)); gp_XYZ Vect13 ((x3-x1), (y3-y1), (z3-z1));
gp_XYZ Vnorm = Vect12 ^ Vect13; gp_XYZ Vnorm = Vect12 ^ Vect13;
Standard_Real Vmodul = Vnorm.Modulus (); Standard_Real Vmodul = Vnorm.Modulus ();
if (Vmodul > gp::Resolution()) { if (Vmodul > gp::Resolution())
{
Vnorm.Divide(Vmodul); Vnorm.Divide(Vmodul);
} }
else { else
{
// si Vnorm est quasi-nul, on le charge a 0 explicitement // si Vnorm est quasi-nul, on le charge a 0 explicitement
Vnorm.SetCoord (0., 0., 0.); Vnorm.SetCoord (0., 0., 0.);
} }
WriteDouble2Float (theFile,Vnorm.X()); WriteDouble2Float (aFile, Vnorm.X());
WriteDouble2Float (theFile,Vnorm.Y()); WriteDouble2Float (aFile, Vnorm.Y());
WriteDouble2Float (theFile,Vnorm.Z()); WriteDouble2Float (aFile, Vnorm.Z());
WriteDouble2Float (theFile,x1); WriteDouble2Float (aFile, x1);
WriteDouble2Float (theFile,y1); WriteDouble2Float (aFile, y1);
WriteDouble2Float (theFile,z1); WriteDouble2Float (aFile, z1);
WriteDouble2Float (theFile,x2); WriteDouble2Float (aFile, x2);
WriteDouble2Float (theFile,y2); WriteDouble2Float (aFile, y2);
WriteDouble2Float (theFile,z2); WriteDouble2Float (aFile, z2);
WriteDouble2Float (theFile,x3); WriteDouble2Float (aFile, x3);
WriteDouble2Float (theFile,y3); WriteDouble2Float (aFile, y3);
WriteDouble2Float (theFile,z3); WriteDouble2Float (aFile, z3);
theFile.Write (&dum,2); aFile.Write (&dum, 2);
// update progress only per 1k triangles
if (++aTriangleInd % IND_THRESHOLD == 0)
{
if (!aTPS.More())
break;
aTPS.Next();
} }
} }
}
theFile.Close (); aFile.Close();
return Standard_True; Standard_Boolean isInterrupted = !aDPS.More();
return !isInterrupted;
} }
//======================================================================= //=======================================================================
//function : WriteAscii //function : WriteAscii
//purpose : write an ASCII STL file //purpose : write an ASCII STL file
//======================================================================= //=======================================================================
Standard_Boolean RWStl::WriteAscii(const Handle(StlMesh_Mesh)& aMesh, const OSD_Path& aPath) Standard_Boolean RWStl::WriteAscii (const Handle(StlMesh_Mesh)& theMesh,
const OSD_Path& thePath,
const Handle(Message_ProgressIndicator)& theProgInd)
{ {
OSD_File theFile = OSD_File (aPath); OSD_File theFile (thePath);
theFile.Build(OSD_WriteOnly,OSD_Protection()); theFile.Build(OSD_WriteOnly,OSD_Protection());
TCollection_AsciiString buf = TCollection_AsciiString ("solid\n"); TCollection_AsciiString buf ("solid\n");
theFile.Write (buf,buf.Length());buf.Clear(); theFile.Write (buf,buf.Length());buf.Clear();
Standard_Real x1, y1, z1; Standard_Real x1, y1, z1;
Standard_Real x2, y2, z2; Standard_Real x2, y2, z2;
Standard_Real x3, y3, z3; Standard_Real x3, y3, z3;
char sval[512];
//pgo Standard_Real x,y,z; // create progress sentry for domains
Standard_Integer aNbDomains = theMesh->NbDomains();
char sval[16]; Message_ProgressSentry aDPS (theProgInd, "Mesh domains", 0, aNbDomains, 1);
StlMesh_MeshExplorer aMexp (theMesh);
StlMesh_MeshExplorer aMexp (aMesh); for (Standard_Integer nbd = 1; nbd <= aNbDomains && aDPS.More(); nbd++, aDPS.Next())
{
for (Standard_Integer nbd=1;nbd<=aMesh->NbDomains();nbd++) { // create progress sentry for triangles in domain
for (aMexp.InitTriangle (nbd); aMexp.MoreTriangle (); aMexp.NextTriangle ()) { Message_ProgressSentry aTPS (theProgInd, "Triangles", 0,
theMesh->NbTriangles (nbd), IND_THRESHOLD);
Standard_Integer aTriangleInd = 0;
for (aMexp.InitTriangle (nbd); aMexp.MoreTriangle(); aMexp.NextTriangle())
{
aMexp.TriangleVertices (x1,y1,z1,x2,y2,z2,x3,y3,z3); aMexp.TriangleVertices (x1,y1,z1,x2,y2,z2,x3,y3,z3);
// Standard_Real x, y, z; // Standard_Real x, y, z;
@ -205,74 +227,44 @@ Standard_Boolean RWStl::WriteAscii(const Handle(StlMesh_Mesh)& aMesh, const OSD_
gp_XYZ Vect23 ((x3-x2), (y3-y2), (z3-z2)); gp_XYZ Vect23 ((x3-x2), (y3-y2), (z3-z2));
gp_XYZ Vnorm = Vect12 ^ Vect23; gp_XYZ Vnorm = Vect12 ^ Vect23;
Standard_Real Vmodul = Vnorm.Modulus (); Standard_Real Vmodul = Vnorm.Modulus ();
if (Vmodul > gp::Resolution()){ if (Vmodul > gp::Resolution())
{
Vnorm.Divide (Vmodul); Vnorm.Divide (Vmodul);
} }
else { else
{
// si Vnorm est quasi-nul, on le charge a 0 explicitement // si Vnorm est quasi-nul, on le charge a 0 explicitement
Vnorm.SetCoord (0., 0., 0.); Vnorm.SetCoord (0., 0., 0.);
} }
buf += " facet normal "; sprintf (sval,
sprintf (sval,"% 12e",Vnorm.X()); " facet normal % 12e % 12e % 12e\n"
buf += sval; " outer loop\n"
buf += " "; " vertex % 12e % 12e % 12e\n"
sprintf (sval,"% 12e",Vnorm.Y()); " vertex % 12e % 12e % 12e\n"
buf += sval; " vertex % 12e % 12e % 12e\n"
buf += " "; " endloop\n"
sprintf (sval,"% 12e",Vnorm.Z()); " endfacet\n",
buf += sval; Vnorm.X(), Vnorm.Y(), Vnorm.Z(),
buf += '\n'; x1, y1, z1,
theFile.Write (buf,buf.Length());buf.Clear(); x2, y2, z2,
buf += " outer loop\n"; x3, y3, z3);
theFile.Write (buf,buf.Length());buf.Clear(); theFile.Write (buf, buf.Length()); buf.Clear();
buf += " vertex "; // update progress only per 1k triangles
sprintf (sval,"% 12e",x1); if (++aTriangleInd % IND_THRESHOLD == 0)
buf += sval; {
buf += " "; if (!aTPS.More())
sprintf (sval,"% 12e",y1); break;
buf += sval; aTPS.Next();
buf += " "; }
sprintf (sval,"% 12e",z1);
buf += sval;
buf += '\n';
theFile.Write (buf,buf.Length());buf.Clear();
buf += " vertex ";
sprintf (sval,"% 12e",x2);
buf += sval;
buf += " ";
sprintf (sval,"% 12e",y2);
buf += sval;
buf += " ";
sprintf (sval,"% 12e",z2);
buf += sval;
buf += '\n';
theFile.Write (buf,buf.Length());buf.Clear();
buf += " vertex ";
sprintf (sval,"% 12e",x3);
buf += sval;
buf += " ";
sprintf (sval,"% 12e",y3);
buf += sval;
buf += " ";
sprintf (sval,"% 12e",z3);
buf += sval;
buf += '\n';
theFile.Write (buf,buf.Length());buf.Clear();
buf += " endloop\n";
theFile.Write (buf,buf.Length());buf.Clear();
buf += " endfacet\n";
theFile.Write (buf,buf.Length());buf.Clear();
} }
} }
buf += "endsolid\n"; buf += "endsolid\n";
theFile.Write (buf,buf.Length());buf.Clear(); theFile.Write (buf, buf.Length()); buf.Clear();
theFile.Close();
theFile.Close (); Standard_Boolean isInterrupted = !aDPS.More();
return Standard_True; return !isInterrupted;
} }
//======================================================================= //=======================================================================
//function : ReadFile //function : ReadFile
@ -280,9 +272,10 @@ Standard_Boolean RWStl::WriteAscii(const Handle(StlMesh_Mesh)& aMesh, const OSD_
//Warning : //Warning :
//======================================================================= //=======================================================================
Handle_StlMesh_Mesh RWStl::ReadFile(const OSD_Path& aPath) Handle_StlMesh_Mesh RWStl::ReadFile (const OSD_Path& thePath,
const Handle(Message_ProgressIndicator)& theProgInd)
{ {
OSD_File file = OSD_File (aPath); OSD_File file (thePath);
file.Open(OSD_ReadOnly,OSD_Protection(OSD_RWD,OSD_RWD,OSD_RWD,OSD_RWD)); file.Open(OSD_ReadOnly,OSD_Protection(OSD_RWD,OSD_RWD,OSD_RWD,OSD_RWD));
Standard_Boolean IsAscii; Standard_Boolean IsAscii;
unsigned char str[128]; unsigned char str[128];
@ -307,11 +300,8 @@ Handle_StlMesh_Mesh RWStl::ReadFile(const OSD_Path& aPath)
#endif #endif
file.Close(); file.Close();
if (IsAscii) { return IsAscii ? RWStl::ReadAscii (thePath, theProgInd)
return RWStl::ReadAscii (aPath); : RWStl::ReadBinary (thePath, theProgInd);
} else {
return RWStl::ReadBinary (aPath);
}
} }
//======================================================================= //=======================================================================
@ -320,7 +310,8 @@ Handle_StlMesh_Mesh RWStl::ReadFile(const OSD_Path& aPath)
//Warning : //Warning :
//======================================================================= //=======================================================================
Handle_StlMesh_Mesh RWStl::ReadBinary(const OSD_Path& aPath) Handle_StlMesh_Mesh RWStl::ReadBinary (const OSD_Path& thePath,
const Handle(Message_ProgressIndicator)& /*theProgInd*/)
{ {
Standard_Integer NBFACET; Standard_Integer NBFACET;
Standard_Integer ifacet; Standard_Integer ifacet;
@ -331,7 +322,7 @@ Handle_StlMesh_Mesh RWStl::ReadBinary(const OSD_Path& aPath)
adr = (Standard_Address)buftest; adr = (Standard_Address)buftest;
// Open the file // Open the file
OSD_File theFile = OSD_File(aPath); OSD_File theFile (thePath);
theFile.Open(OSD_ReadOnly,OSD_Protection(OSD_RWD,OSD_RWD,OSD_RWD,OSD_RWD)); theFile.Open(OSD_ReadOnly,OSD_Protection(OSD_RWD,OSD_RWD,OSD_RWD,OSD_RWD));
// the size of the file (minus the header size) // the size of the file (minus the header size)
@ -396,7 +387,8 @@ Handle_StlMesh_Mesh RWStl::ReadBinary(const OSD_Path& aPath)
//Warning : //Warning :
//======================================================================= //=======================================================================
Handle_StlMesh_Mesh RWStl::ReadAscii(const OSD_Path& aPath) Handle_StlMesh_Mesh RWStl::ReadAscii (const OSD_Path& thePath,
const Handle(Message_ProgressIndicator)& theProgInd)
{ {
TCollection_AsciiString filename; TCollection_AsciiString filename;
long ipos; long ipos;
@ -407,7 +399,7 @@ Handle_StlMesh_Mesh RWStl::ReadAscii(const OSD_Path& aPath)
Standard_Integer i1,i2,i3; Standard_Integer i1,i2,i3;
Handle(StlMesh_Mesh) ReadMesh; Handle(StlMesh_Mesh) ReadMesh;
aPath.SystemName( filename); thePath.SystemName (filename);
// Open the file // Open the file
FILE* file = fopen(filename.ToCString(),"r"); FILE* file = fopen(filename.ToCString(),"r");
@ -444,7 +436,9 @@ Handle_StlMesh_Mesh RWStl::ReadAscii(const OSD_Path& aPath)
ReadMesh->AddDomain(); ReadMesh->AddDomain();
// main reading // main reading
for (iTri = 0; iTri < nbTris; ++iTri) { Message_ProgressSentry aPS (theProgInd, "Triangles", 0, (nbTris - 1) * 1.0 / IND_THRESHOLD, 1);
for (iTri = 0; iTri < nbTris && aPS.More();)
{
// reading the facet normal // reading the facet normal
fscanf(file,"%*s %*s %f %f %f\n",&x[0],&y[0],&z[0]); fscanf(file,"%*s %*s %f %f %f\n",&x[0],&y[0],&z[0]);
@ -469,6 +463,9 @@ Handle_StlMesh_Mesh RWStl::ReadAscii(const OSD_Path& aPath)
// skip the keywords "endfacet" // skip the keywords "endfacet"
fscanf(file,"%*s"); fscanf(file,"%*s");
// update progress only per 1k triangles
if (++iTri % IND_THRESHOLD == 0)
aPS.Next();
} }
#ifdef DEB #ifdef DEB
cout << "end mesh\n"; cout << "end mesh\n";

6
src/XSDRAWSTLVRML/XSDRAWSTLVRML.cxx
View File

@ -24,6 +24,7 @@
#include <AIS_InteractiveContext.hxx> #include <AIS_InteractiveContext.hxx>
#include <ViewerTest.hxx> #include <ViewerTest.hxx>
#include <Draw.hxx> #include <Draw.hxx>
#include <Draw_ProgressIndicator.hxx>
#include <RWStl.hxx> #include <RWStl.hxx>
#include <Quantity_Color.hxx> #include <Quantity_Color.hxx>
#include <V3d_View.hxx> #include <V3d_View.hxx>
@ -233,9 +234,10 @@ static Standard_Integer createmesh
return 1; return 1;
} }
// Progress indicator
OSD_Path aFile( argv[2] ); OSD_Path aFile( argv[2] );
Handle( StlMesh_Mesh ) aSTLMesh = RWStl::ReadFile( aFile ); Handle(Draw_ProgressIndicator) aProgress = new Draw_ProgressIndicator (di, 1);
// DBRep::Set(argv[1],shape); Handle(StlMesh_Mesh) aSTLMesh = RWStl::ReadFile (aFile, aProgress);
di << "Reading OK..." << "\n"; di << "Reading OK..." << "\n";
Handle( XSDRAWSTLVRML_DataSource ) aDS = new XSDRAWSTLVRML_DataSource( aSTLMesh ); Handle( XSDRAWSTLVRML_DataSource ) aDS = new XSDRAWSTLVRML_DataSource( aSTLMesh );