ON_BOOL32
ON_CurveOnSurface::Read(
ON_BinaryArchive& file // open binary file
)
{
delete m_c2;
delete m_c3;
m_c2 = 0;
m_c3 = 0;
delete m_s;
m_s = 0;
ON_Object *o=0;
ON_BOOL32 rc = file.ReadObject(&o);
if (rc && o) {
m_c2 = ON_Curve::Cast(o);
if ( !m_c2 ) {
delete o;
} rc = false;
}
o = 0;
ON_BOOL32 bHasC3 = 0;
rc = file.ReadInt( &bHasC3 );
if ( rc && bHasC3 ) {
if (rc)
rc = file.ReadObject(&o);
if ( rc && o ) {
m_c2 = ON_Curve::Cast(o);
if ( !m_c2 ) {
delete o;
} rc = false;
}
}
o = 0;
if (rc)
rc = file.ReadObject(&o);
if (rc&&o) {
m_s = ON_Surface::Cast(o);
if ( !m_s ) {
delete o;
rc = false;
}
}
return rc;
}
// virtual ON_Object override
ON_BOOL32 ON__IDefLayerSettingsUserData::Read(ON_BinaryArchive& binary_archive)
{
DestroyHelper();
int major_version = 0;
int minor_version = 0;
bool rc = binary_archive.BeginRead3dmChunk(TCODE_ANONYMOUS_CHUNK,&major_version,&minor_version);
if ( !rc )
return false;
rc = false;
while ( 1 == major_version )
{
if ( !binary_archive.ReadArray(m_layers) )
break;
if ( minor_version <= 0 )
{
rc = true;
break;
}
// added in version 1.1 chunks
bool bHaveParentLayer = false;
if ( !binary_archive.ReadBool(&bHaveParentLayer) )
break;
if ( bHaveParentLayer )
{
ON_Object* p = 0;
if ( !binary_archive.ReadObject(&p) || 0 == p )
{
if (p)
{
delete p;
break;
}
}
m_idef_layer_table_parent_layer = ON_Layer::Cast(p);
if ( 0 == m_idef_layer_table_parent_layer )
{
delete p;
break;
}
}
rc = true;
break;
}
if ( !binary_archive.EndRead3dmChunk() )
rc = false;
return rc;
}
ON_BOOL32 ON_SurfaceArray::Read( ON_BinaryArchive& file )
{
int major_version = 0;
int minor_version = 0;
ON__UINT32 tcode = 0;
ON__INT64 big_value = 0;
int flag;
Destroy();
ON_BOOL32 rc = file.BeginRead3dmBigChunk( &tcode, &big_value );
if (rc)
{
rc = ( tcode == TCODE_ANONYMOUS_CHUNK );
if (rc) rc = file.Read3dmChunkVersion(&major_version,&minor_version);
if (rc && major_version == 1) {
ON_Object* p;
int count;
ON_BOOL32 rc = file.ReadInt( &count );
if (rc) {
SetCapacity(count);
SetCount(count);
Zero();
int i;
for ( i = 0; rc && i < count && rc; i++ ) {
flag = 0;
rc = file.ReadInt(&flag);
if (rc && flag==1) {
p = 0;
rc = file.ReadObject( &p ); // polymorphic surfaces
m_a[i] = ON_Surface::Cast(p);
if ( !m_a[i] )
delete p;
}
}
}
}
else {
rc = false;
}
if ( !file.EndRead3dmChunk() )
rc = false;
}
return rc;
}
BOOL ON_HatchLoop::Read( ON_BinaryArchive& ar)
{
m_type = ltOuter;
delete m_p2dCurve;
m_p2dCurve = NULL;
int major_version = 0;
int minor_version = 0;
BOOL rc = ar.Read3dmChunkVersion( &major_version, &minor_version);
if ( major_version == 1 )
{
int type;
if( rc) rc = ar.ReadInt( &type);
if( rc)
{
switch( type)
{
case ltOuter: m_type = ltOuter; break;
case ltInner: m_type = ltInner; break;
default: rc = false; break;
}
}
if( rc)
{
ON_Object* pObj = NULL;
rc = ar.ReadObject( &pObj);
if( pObj)
{
m_p2dCurve = ON_Curve::Cast( pObj);
if( !m_p2dCurve) // read something, but it wasn't right
{
rc = false;
delete pObj;
}
}
}
}
return rc;
}
bool ON_Brep::ReadOld200( ON_BinaryArchive& file, int minor_version )
{
bool rc = true;
// read legacy trimmed surface collection from Rhino 2.0
int face_count = 0;
int edge_count = 0;
int loop_count = 0;
int trim_count = 0;
int outer_flag = 0;
ON_BoundingBox bnd_2d_bbox;
int i, fi, fbi, fbcnt, bti, btcnt, twin_index;
int ftype_flag, btype_flag, gcon_flag, mono_flag;
char b;
if (rc) rc = file.ReadInt( &face_count );
if (rc) rc = file.ReadInt( &edge_count );
if (rc) rc = file.ReadInt( &loop_count );
if (rc) rc = file.ReadInt( &trim_count );
if ( face_count < 1 || edge_count < 1 || loop_count < 1 || trim_count < 1 )
rc = false;
if (rc) rc = file.ReadInt( &outer_flag );
if (rc) rc = file.ReadPoint( m_bbox.m_min );
if (rc) rc = file.ReadPoint( m_bbox.m_max );
// 2d curves
m_C2.Reserve(trim_count);
for ( i = 0; rc && i < trim_count; i++ ) {
ON_PolyCurve* curve = new ON_PolyCurve();
rc = curve->Read( file )?true:false;
if ( curve->Count() == 1 ) {
m_C2.Append( curve->HarvestSegment(0) );
delete curve;
}
else
m_C2.Append( curve );
}
const int c2_count = m_C2.Count();
// 3d curves
m_C3.Reserve(edge_count);
for ( i = 0; rc && i < edge_count; i++ ) {
ON_PolyCurve* curve = new ON_PolyCurve();
rc = curve->Read( file )?true:false;
if ( curve->Count() == 1 ) {
m_C3.Append( curve->HarvestSegment(0) );
delete curve;
}
else
m_C3.Append( curve );
}
const int c3_count = m_C3.Count();
// make a new edge for each 3d curve
m_E.Reserve(c3_count);
for ( i = 0; i < c3_count && rc; i++ )
{
NewEdge(i);
}
// 3d surfaces
m_S.Reserve(face_count);
for ( i = 0; rc && i < face_count; i++ ) {
ON_NurbsSurface* surface = new ON_NurbsSurface();
rc = surface->Read( file )?true:false;
m_S.Append( surface );
}
ON_SimpleArray<int> te_index(trim_count);
ON_SimpleArray<int> te_twin_index(trim_count);
m_F.Reserve(face_count);
m_L.Reserve(loop_count);
m_T.Reserve(trim_count);
for ( fi = 0; rc && fi < face_count; fi++ )
{
ftype_flag = 0;
fbcnt = 0;
ON_BrepFace& f = NewFace(fi);
if (rc) rc = file.ReadInt( &i ); // legacy face index
if (rc) rc = file.ReadInt( &i ); // OBSOLETE f.m_material_index
int k = f.m_bRev;
if (rc) rc = file.ReadInt( &k );
if (rc) f.m_bRev = (k!=0);
if (rc) rc = file.ReadInt( &ftype_flag );
if (rc) rc = file.ReadPoint( f.m_bbox.m_min );
if (rc) rc = file.ReadPoint( f.m_bbox.m_max );
if (rc) rc = file.ReadInt( &fbcnt);
if (fbcnt < 1 )
rc = false;
for ( fbi = 0; rc && fbi < fbcnt; fbi++ ) {
btype_flag = 0;
ON_BrepLoop::TYPE looptype = ON_BrepLoop::unknown;
if (rc) rc = file.ReadInt( &i ); // legacy loop index
if (rc) rc = file.ReadInt( &btype_flag );
switch (btype_flag)
{
case 0:
looptype = ON_BrepLoop::outer;
break;
case 1:
looptype = ON_BrepLoop::inner;
break;
case -1:
looptype = ON_BrepLoop::slit;
break;
default:
looptype = ON_BrepLoop::unknown;
break;
}
if (rc) rc = file.ReadDouble( 2, &bnd_2d_bbox.m_min.x );
if (rc) rc = file.ReadDouble( 2, &bnd_2d_bbox.m_max.x );
btcnt = 0;
if (rc) rc = file.ReadInt( &btcnt );
if (btcnt < 1 )
rc = false;
ON_BrepLoop& bnd = NewLoop(looptype,f);
for ( bti = 0; rc && bti < btcnt; bti++ ) {
ON_BrepTrim& trim = NewTrim(false,bnd,m_T.Count());
te_index.Append(trim.m_trim_index);
if (rc) rc = file.ReadInt( &i ); // legacy trim index
if ( trim.m_trim_index != i )
{
ON_ERROR("ON_Brep::ReadOld200 - trim.m_trim_index out of synch.");
//rc = false;
//break;
}
if (rc) rc = file.ReadInt( &twin_index );
te_twin_index.Append(twin_index);
b = 0;
if (rc) rc = file.ReadChar( &b ); // true if legacy trim managed 3d edge
if (rc) rc = file.ReadInt( &trim.m_ei );
if (b) {
if ( trim.m_ei < 0 || trim.m_ei >= c3_count )
{
trim.m_ei = -1;
ON_ERROR("ON_Brep::ReadOld201 - trim.m_ei out of range.");
rc = false;
break;
}
}
if ( trim.m_trim_index >= 0 && trim.m_trim_index < c2_count )
trim.m_c2i = trim.m_trim_index;
else {
ON_ERROR("ON_Brep::ReadOld200 - trim.m_trim_index out of range.");
rc = false;
trim.m_c2i = -1;
break;
}
int k = trim.m_bRev3d;
if (rc) rc = file.ReadInt(&k);
if (rc) trim.m_bRev3d = (k!=0);
if (rc) rc = file.ReadInt(&gcon_flag);
if (rc) rc = file.ReadInt(&mono_flag);
if (rc) rc = file.ReadDouble(&trim.m__legacy_3d_tol);
if (rc) rc = file.ReadDouble(&trim.m__legacy_2d_tol);
}
}
}
// finish hooking trims to edges
if (rc) {
int trim_index;
for ( i = 0; i < trim_count; i++ ) {
trim_index = te_index[i];
if ( trim_index >= 0 && trim_index < m_T.Count() )
continue;
twin_index = te_twin_index[i];
if ( twin_index >= 0 && twin_index < m_T.Count() )
continue;
ON_BrepTrim& trim1 = m_T[trim_index];
ON_BrepTrim& trim2 = m_T[twin_index];
if ( trim1.m_ei >= 0 && trim1.m_ei < c2_count && trim2.m_ei < 0 )
trim2.m_ei = trim1.m_ei;
else if ( trim2.m_ei >= 0 && trim2.m_ei < c2_count && trim1.m_ei < 0 )
trim1.m_ei = trim2.m_ei;
}
for ( i = 0; i < m_T.Count(); i++ ) {
ON_BrepTrim& trim = m_T[i];
ON_Curve* tcurve = m_C2[trim.m_c2i];
trim.SetProxyCurve( tcurve );
if ( trim.m_ei >= 0 && trim.m_ei < c3_count )
m_E[trim.m_ei].m_ti.Append(trim.m_trim_index);
}
// finish setting flags
SetTrimIsoFlags();
SetTrimTypeFlags();
// create 3d vertex information
SetVertices();
// set tols from values in file
SetTolsFromLegacyValues();
}
else {
Destroy();
}
if (rc) {
// 3d render mesh geometry
ON_Object* obj;
for ( i = 0; rc && i < face_count; i++ ) {
ON_BrepFace& f = m_F[i];
file.ReadChar(&b);
if (b) {
obj = 0;
rc = (file.ReadObject(&obj)==1)?true:false;
f.m_render_mesh = ON_Mesh::Cast(obj);
if ( !f.m_render_mesh )
delete obj;
}
}
if ( !rc ) {
// delete render mesh geometry
for ( i = 0; i < face_count; i++ ) {
ON_BrepFace& f = m_F[i];
if ( f.m_render_mesh ) {
delete f.m_render_mesh;
f.m_render_mesh = 0;
}
}
}
if (rc && minor_version >= 1) {
// 3d analysis mesh geometry
for ( i = 0; rc && i < face_count; i++ ) {
ON_BrepFace& f = m_F[i];
file.ReadChar(&b);
if (b) {
obj = 0;
rc = file.ReadObject(&obj)?true:false;
f.m_analysis_mesh = ON_Mesh::Cast(obj);
if ( !f.m_analysis_mesh )
delete obj;
}
}
if ( !rc ) {
// delete analysis mesh geometry
for ( i = 0; i < face_count; i++ ) {
ON_BrepFace& f = m_F[i];
if ( f.m_analysis_mesh ) {
delete f.m_analysis_mesh;
f.m_analysis_mesh = 0;
}
}
}
}
// fill in missing information
ReadFillInMissingBoxes(*this);
if (!rc ) {
ON_ERROR("ON_Brep::ReadOld201() - trouble reading render/analysis meshes");
rc = true;
}
}
// 22 April 2003:
// Use outer_flag to set m_is_solid for closed solids
// with outward pointing normals.
if ( 1 == outer_flag && IsSolid() )
m_is_solid = 1;
return rc;
}
BOOL ON_Brep::Read( ON_BinaryArchive& file )
{
int i;
int C2_count = 0;
int C3_count = 0;
int S_count = 0;
int major_version = 0;
int minor_version = 0;
BOOL rc = file.Read3dmChunkVersion( &major_version, &minor_version );
if ( rc && major_version == 2 )
{
rc = ReadOld200(file,minor_version); // legacy trimmed face
}
else if ( rc && major_version == 3 )
{
// 2d curves
if (rc)
rc = m_C2.Read(file);
C2_count = m_C2.Count();
// 3d curves
if (rc)
rc = m_C3.Read(file);
C3_count = m_C3.Count();
// untrimmed surfaces
if (rc)
rc = m_S.Read(file);
S_count = m_S.Count();
// vertices
if (rc)
rc = m_V.Read(file);
// edges
if (rc)
{
rc = m_E.Read(file);
if (rc) {
for ( i = 0; i < m_E.Count(); i++ ) {
ON_BrepEdge& e = m_E[i];
e.m_brep = this;
if ( e.m_c3i >= 0 && e.m_c3i < C3_count )
{
bool bProxyCurveIsReversed = e.ProxyCurveIsReversed();
ON_Interval pdom = e.ProxyCurveDomain();
ON_Interval edom = e.Domain();
e.SetProxyCurve( m_C3[e.m_c3i], pdom );
if ( bProxyCurveIsReversed )
e.ON_CurveProxy::Reverse();
e.SetDomain(edom);
}
}
}
}
// trims
if (rc)
{
rc = m_T.Read(file);
if (rc) {
for ( i = 0; i < m_T.Count(); i++ ) {
ON_BrepTrim& trim = m_T[i];
trim.m_brep = this;
if ( trim.m_c2i >= 0 && trim.m_c2i < C2_count )
{
bool bProxyCurveIsReversed = trim.ProxyCurveIsReversed();
ON_Interval pdom = trim.ProxyCurveDomain();
ON_Interval tdom = trim.Domain();
trim.SetProxyCurve( m_C2[trim.m_c2i], pdom );
if ( bProxyCurveIsReversed )
trim.ON_CurveProxy::Reverse();
trim.SetDomain(tdom);
}
}
}
}
// loops
if (rc)
{
rc = m_L.Read(file);
if ( rc )
{
for ( i = 0; i < m_L.Count(); i++ )
{
m_L[i].m_brep = this;
}
}
}
// faces
if (rc)
{
rc = m_F.Read(file);
if (rc) {
for ( i = 0; i < m_F.Count(); i++ ) {
ON_BrepFace& f = m_F[i];
f.m_brep = this;
if ( f.m_si >= 0 && f.m_si < S_count )
f.SetProxySurface(m_S[f.m_si]);
}
}
}
// bounding box
if (rc)
rc = file.ReadPoint( m_bbox.m_min );
if (rc)
rc = file.ReadPoint( m_bbox.m_max );
// fill in missing information
ReadFillInMissingBoxes(*this);
// end of chunk version 3.0
if (rc && minor_version >= 1 )
{
// added for chunk version 3.1
ON_Object* obj;
unsigned int tcode;
int value, fi;
unsigned char b;
const int face_count = m_F.Count();
// read render meshes
rc = file.BeginRead3dmChunk( &tcode, &value );
if ( rc )
{
if ( tcode != TCODE_ANONYMOUS_CHUNK )
rc = false;
else
{
for ( fi = 0; rc && fi < face_count; fi++ )
{
rc = file.ReadChar(&b);
if (rc && b)
{
rc = file.ReadObject(&obj);
m_F[fi].m_render_mesh = ON_Mesh::Cast(obj);
if ( !m_F[fi].m_render_mesh )
delete obj;
}
}
}
if ( !file.EndRead3dmChunk() )
rc = false;
}
// read analysis meshes
rc = file.BeginRead3dmChunk( &tcode, &value );
if ( rc )
{
if ( tcode != TCODE_ANONYMOUS_CHUNK )
rc = false;
else
{
for ( fi = 0; rc && fi < face_count; fi++ )
{
rc = file.ReadChar(&b);
if (rc && b)
{
rc = file.ReadObject(&obj);
m_F[fi].m_analysis_mesh = ON_Mesh::Cast(obj);
if ( !m_F[fi].m_analysis_mesh )
delete obj;
}
}
}
if ( !file.EndRead3dmChunk() )
rc = false;
}
}
if ( rc && minor_version >= 2 )
{
rc = file.ReadInt( &m_is_solid );
if ( m_is_solid < 0 || m_is_solid >= 3 )
m_is_solid = 0;
}
}
if ( file.ArchiveOpenNURBSVersion() < 20021002 )
{
m_is_solid = 0;
}
return rc;
}
bool ON_Brep::ReadOld101( ON_BinaryArchive& file )
{
ON_Object* pO = NULL;
ON_Curve* pC = NULL;
ON_Surface* pS = NULL;
int i, count;
// 2d curves
file.ReadInt( &count );
m_C2.Reserve(count);
for ( i = 0; i < count; i++ )
{
pO = NULL;
file.ReadObject( &pO );
pC = ON_Curve::Cast(pO);
if ( !pC )
delete pO; // ERROR!
m_C2.Append( pC );
pC = NULL;
pO = NULL;
}
// 3d curves
file.ReadInt( &count );
m_C3.Reserve(count);
for ( i = 0; i < count; i++ )
{
pO = NULL;
file.ReadObject( &pO );
pC = ON_Curve::Cast(pO);
if ( !pC )
delete pO; // ERROR!
m_C3.Append( pC );
pC = NULL;
pO = NULL;
}
// untrimmed surfaces
file.ReadInt( &count );
m_S.Reserve(count);
for ( i = 0; i < count; i++ )
{
pO = NULL;
file.ReadObject( &pO );
pS = ON_Surface::Cast(pO);
if ( !pS )
delete pO; // ERROR!
m_S.Append( pS );
pS = NULL;
pO = NULL;
}
// vertices
file.ReadInt( &count );
m_V.Reserve(count);
m_V.SetCount(count);
for ( i = 0; i < count; i++ )
{
m_V[i].Read(file);
}
// edges
file.ReadInt( &count );
m_E.Reserve(count);
m_E.SetCount(count);
for ( i = 0; i < count; i++ )
{
ON_BrepEdge& edge = m_E[i];
edge.Read(file);
edge.SetProxyCurve( edge.m_c3i >= 0 ? m_C3[edge.m_c3i] : 0 );
edge.m_brep = this;
}
// trims
file.ReadInt( &count );
m_T.Reserve(count);
m_T.SetCount(count);
for ( i = 0; i < count; i++ )
{
m_T[i].Read(file);
ON_BrepTrim& trim = m_T[i];
trim.SetProxyCurve( trim.m_c2i >= 0 ? m_C2[trim.m_c2i] : 0 );
trim.m_brep = this;
}
// loops
file.ReadInt( &count );
m_L.Reserve(count);
m_L.SetCount(count);
for ( i = 0; i < count; i++ )
{
m_L[i].Read(file);
m_L[i].m_brep = this;
}
// faces
file.ReadInt( &count );
m_F.Reserve(count);
m_F.SetCount(count);
for ( i = 0; i < count; i++ )
{
ON_BrepFace& face = m_F[i];
face.Read(file);
face.SetProxySurface(face.m_si >= 0 ? m_S[face.m_si] : 0);
face.m_brep = this;
}
// bounding box
file.ReadPoint( m_bbox.m_min );
file.ReadPoint( m_bbox.m_max );
// fill in missing information
ReadFillInMissingBoxes(*this);
return true;
}
