RhinoParser.cc

Go to the documentation of this file.

#include <esg/parser/RhinoParser.h>
#include <esg/Material.h>
#include <esg/geometry/NurbsSurface.h>
#include <esg/SpotLight.h>
#include <esg/DirLight.h>
#include <esg/PointLight.h>
#include <esg/LightSource.h>

using namespace esg;

//const int RhinoParser::_objectFilter = ON::point_object      |
//                                       ON::pointset_object   |
//                                       ON::curve_object      |
//                                       ON::surface_object    |
//                                       ON::brep_object       |
//                                       ON::mesh_object;

const int RhinoParser::_objectFilter = ON::mesh_object;


bool RhinoParser::_read_bitmap_table(ON_BinaryFile& file)
{
    BOOL rc;
    
    if (file.BeginRead3dmBitmapTable()) {
        // At the moment no bitmaps are embedded so this table is empty
        ON_Bitmap* pBitmap = NULL;
        for(;;) {
            pBitmap = NULL;
            rc = file.Read3dmBitmap(&pBitmap);
            if (rc == 0) break; // end of bitmap table
            if (rc < 0) {
                fprintf(stderr,"RhinoParser WARNING: Corrupt bitmap found. Skipping rest of bitmap table.\n");
                break;
            }
            bitmapTable.Append(pBitmap);
        }

        // If BeginRead3dmBitmapTable() returns TRUE, 
        // then you MUST call EndRead3dmBitmapTable().
        if (!file.EndRead3dmBitmapTable()) {
            fprintf(stderr, "RhinoParser Error: FAILURE in EndRead3dmBitmapTable().\n");
            return false;
        }
    } else {
        fprintf(stderr, "RhinoParser WARNING: Missing or corrupt bitmap table - attempting to continue.\n");
    }

    return true;
}

bool RhinoParser::_read_material_table(ON_BinaryFile& file)
{
    BOOL rc;
    ON_ClassArray<ON_Material> materialTable;
    
    if (file.BeginRead3dmMaterialTable()) {
        ON_Material* pMaterial = NULL;
        for(;;) {
            rc = file.Read3dmMaterial(&pMaterial);
            if (rc == 0) break; // end of material table
            if (rc < 0) {
                fprintf(stderr, "RhinoParser WARNING: Corrupt render material found. Skipping to material table.\n");
                break;
            }
            materialTable.Append(*pMaterial);
            delete pMaterial;
            pMaterial = NULL;
        }
      
        // If BeginRead3dmMaterialTable() returns TRUE, 
        // then you MUST call EndRead3dmMaterialTable().
        if (!file.EndRead3dmMaterialTable()) {
            fprintf(stderr, "RhinoParser Error: FAILURE in EndRead3dmMaterialTable().\n");
            return false;
        }
    } else 
        fprintf(stderr, "RhinoParser WARNING: Missing or corrupt render material table - attempting to continue.\n");

    // fill shared materials
    _matTableSize = materialTable.Count();
    _specularMatTable  = new AutoPtr<Material>* [_matTableSize];
    _diffuseMatTable   = new AutoPtr<Material>* [_matTableSize];
    _ambientMatTable   = new AutoPtr<Material>* [_matTableSize];
    //    _emissiveMatTable  = new (AutoPtr<Material>*) [_matTableSize];
    _roughnessMatTable = new AutoPtr<Material>* [_matTableSize];
    for (int i = 0; i < _matTableSize; i++) {
        Color3f specular(materialTable[i].Specular().FractionRed(),
                         materialTable[i].Specular().FractionGreen(),
                         materialTable[i].Specular().FractionBlue());
        Color3f diffuse (materialTable[i].Diffuse().FractionRed(),
                         materialTable[i].Diffuse().FractionGreen(),
                         materialTable[i].Diffuse().FractionBlue());
        Color3f ambient (materialTable[i].Ambient().FractionRed(),
                         materialTable[i].Ambient().FractionGreen(),
                         materialTable[i].Ambient().FractionBlue());
        //      Color3f emissive(materialTable[i].Emission().FractionRed(),
        //                       materialTable[i].Emission().FractionGreen(),
        //                       materialTable[i].Emission().FractionBlue());
        float   sh = materialTable[i].Shine();
        //float   transparency = materialTable[i].Transparency();

        // Snihiness of PhongMat has range [0,1]:
        sh /= materialTable[i].MaxShine();

        //ambient.x = (ambient.y = (ambient.z = 1)); // testing
        
        _specularMatTable[i] =new AutoPtr<Material>(new Specular(specular));
        _diffuseMatTable[i]  =new AutoPtr<Material>(new Diffuse(diffuse));
        _ambientMatTable[i]  =new AutoPtr<Material>(new Ambient(ambient));
        //_emissiveMatTable[i] =new AutoPtr<Material>(new Emissive(emissive));
        _roughnessMatTable[i]=new AutoPtr<Material>(new Roughness(sh));

        _specularMatTable[i]->registerReferer(this);
        _diffuseMatTable[i]->registerReferer(this);
        _ambientMatTable[i]->registerReferer(this);
        //_emissiveMatTable[i]->registerReferer(this);
        _roughnessMatTable[i]->registerReferer(this);
    }

    return true;
}

bool RhinoParser::_read_layer_table(ON_BinaryFile& file)
{
    BOOL rc;
    
    if (file.BeginRead3dmLayerTable()) {
        ON_Layer* pLayer = NULL;
        for(;;) {
            pLayer = NULL;
            rc = file.Read3dmLayer(&pLayer);
            if (rc == 0) break; // end of layer table
            if (rc < 0) {
                fprintf(stderr, "RhinoParser WARNING: Corrupt layer found. Skipping rest of layer table.\n");
                break;
            }
            layerTable.Append(*pLayer);
            delete pLayer;
            pLayer = NULL;
        }
      
        // If BeginRead3dmLayerTable() returns TRUE, 
        // then you MUST call EndRead3dmLayerTable().
        if (!file.EndRead3dmLayerTable()) {
            fprintf(stderr, "RhinoParser Error: FAILURE in EndRead3dmLayerTable().\n");
            return false;
        }
    } else {
        fprintf(stderr, "RhinoParser WARNING: Missing or corrupt layer table - attempting to continue.\n");
    }

    return true;
}

bool RhinoParser::_read_group_table(ON_BinaryFile& file)
{
    BOOL rc;
    
    if (file.BeginRead3dmGroupTable()) {
        ON_Group* pGroup = NULL;
        for(;;) {
            pGroup = NULL;
            rc = file.Read3dmGroup(&pGroup);
            if (rc == 0) break; // end of group table
            if (rc < 0) {
                fprintf(stderr, "RhinoParser WARNING: Corrupt group found. Skipping rest of group table.\n");
                break;
            }
            groupTable.Append(*pGroup);
            delete pGroup;
            pGroup = NULL;
        }
      
        // If BeginRead3dmGroupTable() returns TRUE, 
        // then you MUST call EndRead3dmGroupTable().
        if (!file.EndRead3dmGroupTable()) {
            fprintf(stderr, "RhinoParser Error: FAILURE in EndRead3dmGroupTable().\n");
            return false;
        }
    } else {
        fprintf(stderr, "RhinoParser WARNING: Missing or corrupt group table - attempting to continue.\n");
    }

    return true;
}

bool RhinoParser::_read_lights_table(ON_BinaryFile& file)
{
    BOOL rc;
    ON_3dmObjectAttributes object_attributes;
    Color3f                diffuse;
    bool                   isOn;
    Vector3                location;
    Vector3                direction;
    LightSource*           pNewLight = NULL;
    
    if (file.BeginRead3dmLightTable()) {
        ON_Light* pLight = NULL;
        for(;;) {
            object_attributes.Default();
            rc = file.Read3dmLight(&pLight,&object_attributes);
            if (rc == 0) break; // end of light table
            if (rc < 0) {
                fprintf(stderr, "RhinoParser WARNING: Corrupt render light found. Skipping rest of light table.\n");
                break;
            }

            isOn = pLight->IsEnabled();
            diffuse.set(pLight->Diffuse().FractionRed(),
                        pLight->Diffuse().FractionGreen(),
                        pLight->Diffuse().FractionBlue());
            location.set(pLight->Location().x,
                         pLight->Location().y,
                         pLight->Location().z);
            direction.set(pLight->Direction().x,
                          pLight->Direction().y,
                          pLight->Direction().z);

            switch (pLight->Style()) {
            //case ON::view_directional_light:
            case ON::camera_directional_light:
            case ON::world_directional_light:
                pNewLight = new DirLight(location, direction, diffuse, _oid++);
                break;
            //case ON::view_point_light:
            case ON::camera_point_light:
            case ON::world_point_light:
                pNewLight = new PointLight(location, diffuse, .0, .0, _oid++);
                break;
            //case ON::view_spot_light:
            case ON::camera_spot_light:
            case ON::world_spot_light:
                pNewLight = new SpotLight(location, direction, diffuse, 
                                          pLight->SpotAngleRadians(),
                                          (char) pLight->SpotExponent(),
                                          .0, .0,
                                          _oid++);
                break;
            case ON::ambient_light:
                //pNewLight = new AmbientLight(isOn, diffuse);
                break;
            default:
                // other types of lights are not supported 
                break;
            }

            if (pNewLight) {
                _lights.append(pNewLight);
                pNewLight = NULL;
            }
            delete pLight;
            pLight = NULL;
        }
      
        // If BeginRead3dmLightTable() returns TRUE, 
        // then you MUST call EndRead3dmLightTable().
        if (!file.EndRead3dmLightTable()) {
            fprintf(stderr, "RhinoParser Error: FAILURE in EndRead3dmLightTable().\n");
            return false;
        }
    } else {
        fprintf(stderr, "RhinoParser WARNING: Missing or corrupt light table - attempting to continue.\n");
    }

    return true;
}

Vertex3* RhinoParser::_get_vertices(const ON_Mesh& mesh)
{
    Vertex3*  vertArray = new Vertex3 [mesh.m_V.Count()];
    for (register int i = 0; i < mesh.m_V.Count(); i++) 
        vertArray[i].set(mesh.m_V[i].x, mesh.m_V[i].y, mesh.m_V[i].z);
    return vertArray;
}

Vector3* RhinoParser::_get_normals(const ON_Mesh& mesh)
{
    if (mesh.HasVertexNormals()) {
        Vector3* normArray = new Vector3 [mesh.m_N.Count()];
        for (register int i = 0; i < mesh.m_N.Count(); i++)
            normArray[i].set(mesh.m_N[i].x, mesh.m_N[i].y, mesh.m_N[i].z);
        return normArray;
    }
    return NULL;
}

Vector2* RhinoParser::_get_texture_coords(const ON_Mesh& mesh)
{
    if (mesh.HasTextureCoordinates()) {
        Vector2* textureArray = new Vector2 [mesh.m_T.Count()];
        for (register int i = 0; i < mesh.m_T.Count(); i++)
            textureArray[i].set(mesh.m_T[i].x, mesh.m_T[i].y);
        return textureArray;
    }
    return NULL;
}

void RhinoParser::_set_material(SceneGraphObject&             prim,
                                const ON_3dmObjectAttributes& objAttr) const
{
    int li = -1;
    int mi = -1;

    switch (objAttr.MaterialSource()) {
    case ON::material_from_layer:
        // use material assigned to object's layer
        li = objAttr.m_layer_index;
        if (li >= 0 && li < layerTable.Count()) 
            mi = layerTable[li].RenderMaterialIndex();
        break;
    case ON::material_from_object:
        // use material assigned to object
        mi = objAttr.m_material_index;
        break;
    default:
        mi = -1;
    }

    if (mi < 0 || mi >= _matTableSize) {
        prim.appendSharedMaterial(_pDefSpecularMat);
        prim.appendSharedMaterial(_pDefDiffuseMat);
        prim.appendSharedMaterial(_pDefAmbientMat);
        //      prim.appendSharedAttribute(_pDefEmissiveMat);
        prim.appendSharedMaterial(_pDefRoughnessMat);
    } else {
        prim.appendSharedMaterial(_specularMatTable[mi]);
        prim.appendSharedMaterial(_diffuseMatTable[mi]);
        prim.appendSharedMaterial(_ambientMatTable[mi]);
        //      prim.appendSharedAttribute(_emissiveMatTable[mi]);
        prim.appendSharedMaterial(_roughnessMatTable[mi]);
    }
}

Shape* RhinoParser::_parse_mesh(const ON_Mesh& mesh)
{
    int         fi;
    unsigned    v1[3];
    unsigned    v2[3];

    const int face_count = mesh.FaceCount();

    Surface* pSurface = new Surface(*_pSSProto,
                                    new AutoArray<Vertex3>(_get_vertices(mesh)),
                                    mesh.m_V.Count(),
                                    new AutoArray<Vector3>(_get_normals(mesh)),
                                    mesh.m_N.Count(),
                                    new AutoArray<Vector2>(_get_texture_coords(mesh)),
                                    mesh.m_T.Count(),
                                    Surface::TRIANGLES,
                                    new AutoPtr<Intersector>(new Intersector),
                                    true);

    if (!pSurface) return NULL;
    
    for (fi = 0; fi < face_count; fi++) {
        const ON_MeshFace& f = mesh.m_F[fi];

        if (f.IsQuad()) {
            // quadrangle - render as squared polygon
            if (mesh.m_V[f.vi[0]].DistanceTo(mesh.m_V[f.vi[2]]) <=
                mesh.m_V[f.vi[1]].DistanceTo(mesh.m_V[f.vi[3]])) {
                v1[0] = f.vi[0]; v1[1] = f.vi[1]; v1[2] = f.vi[2];
                v2[0] = f.vi[0]; v2[1] = f.vi[2]; v2[2] = f.vi[3];
            } else {
                v1[0] = f.vi[1]; v1[1] = f.vi[2]; v1[2] = f.vi[3];
                v2[0] = f.vi[1]; v2[1] = f.vi[3]; v2[2] = f.vi[0];
            }
        } else {
            v1[0] = f.vi[0]; v1[1] = f.vi[1]; v1[2] = f.vi[2];
            v2[0] = f.vi[0]; v2[1] = f.vi[0]; v2[2] = f.vi[0];
        }

        // first triangle
        if (mesh.HasVertexNormals()) {
            (void) pSurface->vertex(v1[0],v1[0]);
            (void) pSurface->vertex(v1[1],v1[1]);
            (void) pSurface->vertex(v1[2],v1[2]);
        } else {
            (void) pSurface->vertex(v1[0]);
            (void) pSurface->vertex(v1[1]);
            (void) pSurface->vertex(v1[2]);
        }
            
        if (_pStat) _pStat->primitives++;

        if (v2[0] != v2[1]) {  // if we have a quad, second triagle
            if (mesh.HasVertexNormals()) {
                (void) pSurface->vertex(v2[0],v2[0]);
                (void) pSurface->vertex(v2[1],v2[1]);
                (void) pSurface->vertex(v2[2],v2[2]);
            } else {
                (void) pSurface->vertex(v2[0]);
                (void) pSurface->vertex(v2[1]);
                (void) pSurface->vertex(v2[2]);
            }
            if (_pStat) _pStat->primitives++;
        }
    }

    pSurface->done();

    Shape * pPrim = new Shape(_oid++, "Polygonal Mesh");
    pPrim->setSharedGeometry(new AutoPtr<Geometry>(pSurface));
    
    return pPrim;
}

Shape* RhinoParser::_parse_brep(const ON_Brep& brep, int index)
{
    if (index < 0 || index >= brep.m_F.Count()) {
        fprintf(stderr,"RhinoParser Error: Bad facet index in B-Rep\n");
        return NULL;
    }

    const ON_BrepFace& face = brep.m_F[index];
    
    if (face.m_si < 0 || face.m_si >= brep.m_S.Count()) {
        fprintf(stderr,"RhinoParser Error: Bad surface index in B-Rep\n");
        return NULL;
    } else {
        Shape* pPrim = new Shape(_oid++, "B-Rep");
        NurbsSurface* pSurface = new NurbsSurface(*_pSSProto,
                                                  new AutoPtr<Intersector>(new Intersector),
                                                  (ON_NurbsSurface&)*(brep.m_S[face.m_si]));
        pPrim->setSharedGeometry(new AutoPtr<Geometry>(pSurface));
        return pPrim;
    }
}

void RhinoParser::_parse_object(const ON_Geometry&            geom,
                                const ON_3dmObjectAttributes& objAttr)
{
    const ON_Point*        point;
    const ON_PointCloud*   cloud;
    const ON_Brep*         brep;
    const ON_Mesh*         mesh;
    const ON_Curve*        curve;
    const ON_Surface*      surface;
    const ON_NurbsSurface* nurbsSurface;
    
    mesh = ON_Mesh::Cast(&geom);
    if (mesh) {
        _pParsedObject = _parse_mesh(*mesh);
        if (_pParsedObject)
            _set_material(*_pParsedObject, objAttr);
        return;
    }
    
    curve = ON_Curve::Cast(&geom);
    if (curve) {
        fprintf(stderr, "RhinoParser Warning: skipping unsuported Curve\n");
        //ON_GL( *curve, nobj );
        return;
    }

    nurbsSurface = ON_NurbsSurface::Cast(&geom);
    if (nurbsSurface) {
        NurbsSurface* pSurface = new NurbsSurface(*_pSSProto,
                                                  new AutoPtr<Intersector>(new Intersector),
                                                  *nurbsSurface);
        if (pSurface) {
            _pParsedObject = new Shape(_oid++, "NURBS Surface");
            _set_material(*_pParsedObject, objAttr);
            _pParsedObject->setSharedGeometry(new AutoPtr<Geometry>(pSurface));
        }
        return;
    }
    
    surface = ON_Surface::Cast(&geom);
    if (surface) {
        fprintf(stderr, "RhinoParser Warning: skipping unsuported Surface\n");
        //ON_GL( *surface, nobj );
        return;
    }

    brep = ON_Brep::Cast(&geom);
    if (brep) {
#warning "TODO: Only the first surface of B-Rep is actually parsed"
        _pParsedObject = _parse_brep(*brep, 0);
        if (_pParsedObject)
            _set_material(*_pParsedObject, objAttr);
        return;
    }

    point = ON_Point::Cast(&geom);
    if (point) {
        fprintf(stderr, "RhinoParser Warning: skipping unsuported Point\n");
        //ON_GL(*point);
        return;
    }

    cloud = ON_PointCloud::Cast(&geom);
    if (cloud) {
        fprintf(stderr, "RhinoParser Warning: skipping unsuported Cloud\n");
        //ON_GL(*cloud);
        return;
    }

    fprintf(stderr, "RhinoParser Warning: skipping unsuported unknown object\n");
}

RhinoParser::RhinoParser(const char            * path,
                         const SDS             & proto,
                         SceneGraphObject::OID   firstOID,
                         Parser::Statistics    * pStat)
    : Parser(path, proto, firstOID), _continueReading(false)
{
    _pDefSpecularMat  = new AutoPtr<Material>(new Specular());
    _pDefDiffuseMat   = new AutoPtr<Material>(new Diffuse());
    _pDefAmbientMat   = new AutoPtr<Material>(new Ambient());
    //    _pDefEmissiveMat  = new AutoPtr<Material>(new Emissive());
    _pDefRoughnessMat = new AutoPtr<Material>(new Roughness());

    _pDefSpecularMat->registerReferer(this);
    _pDefDiffuseMat->registerReferer(this);
    _pDefAmbientMat->registerReferer(this);
    //    _pDefEmissiveMat->registerReferer(this);
    _pDefRoughnessMat->registerReferer(this);
        
    _pFile = new ON_BinaryFile(ON::read3dm, _workspace.OpenFile(path, "rb "));
    
    // STEP 1: REQUIRED - Read start section
    if (!_pFile->Read3dmStartSection(&version, startComments)) {
        fprintf(stderr, "RhinoParser Error: FAILURE in Read3dmStartSection().\n");
        return;
    }

    // STEP 2: REQUIRED - Read properties section
    if (!_pFile->Read3dmProperties(properties)) {
        fprintf(stderr, "RhinoParser Error: FAILURE in Read3dmProperties().\n");
        return;
    }
    
    // STEP 3: REQUIRED - Read settings section
    if (!_pFile->Read3dmSettings(settings)) {
        fprintf(stderr, "RhinoParser Error: FAILURE in Read3dmSettings().\n");
        return;
    }

    // STEP 4: REQUIRED - Read embedded bitmap table
    if (!_read_bitmap_table(*_pFile)) return;

    // STEP 5: REQUIRED - Read render material table
    if (!_read_material_table(*_pFile)) return;

    // STEP 6: REQUIRED - Read layer table
    if (!_read_layer_table(*_pFile)) return;

    // STEP 7: REQUIRED - Read group table
    if (!_read_group_table(*_pFile)) return;

    // STEP 8: REQUIRED - Read render lights table
    if (!_read_lights_table(*_pFile)) return;

    // STEP 9: REQUIRED - Read begin of object table
    if (!_pFile->BeginRead3dmObjectTable()) {
        fprintf(stderr, "RhinoParser WARNING: Missing or corrupt object table.\n");
        return;
    }

    _continueReading = true;
}

RhinoParser::~RhinoParser()
{
    AutoPtr<Material>::destroy(_pDefSpecularMat,  this);
    AutoPtr<Material>::destroy(_pDefDiffuseMat,   this);
    AutoPtr<Material>::destroy(_pDefAmbientMat,   this);
    //    AutoPtr<Material>::destroy(_pDefEmissiveMat,  this);
    AutoPtr<Material>::destroy(_pDefRoughnessMat, this);

    for (int i = 0; i < _matTableSize; i++) {
        AutoPtr<Material>::destroy(_specularMatTable[i],  this);
        AutoPtr<Material>::destroy(_diffuseMatTable[i],   this);
        AutoPtr<Material>::destroy(_ambientMatTable[i],   this);
        //      AutoPtr<Material>::destroy(_emissiveMatTable[i],  this);
        AutoPtr<Material>::destroy(_roughnessMatTable[i], this);
    }

    delete [] _specularMatTable;
    delete [] _diffuseMatTable;
    delete [] _ambientMatTable;
    //    delete [] _emissiveMatTable;
    delete [] _roughnessMatTable;
}

bool RhinoParser::parseObject(void)
{
    BOOL                   rc;
    ON_3dmObjectAttributes attributes;
    ON_Geometry *          pGeometry;
    ON_Object *            pObject = NULL;

    _pParsedObject = NULL;

    if (!_continueReading) {
        fprintf(stderr, "RhinoParser Error: Can't continue with reading due to previous error or job finish\n");
        return false;
    }

    while (_continueReading && !_pParsedObject) {
        rc = _pFile->Read3dmObject(&pObject, &attributes, _objectFilter);

        // no more objects
        if (rc == 0) {
            if (!_pFile->EndRead3dmObjectTable())  // close file
                fprintf(stderr, "RhinoParser Error: FAILURE in EndRead3dmObjectTable().\n");
            _continueReading = false;
            continue;
        }

        // error while reding object => unable to continue
        if (rc < 0) {
            fprintf(stderr, "RhinoParser WARNING: Corrupt object found. Skipping rest of object table.\n");
            if (!_pFile->EndRead3dmObjectTable())  // close file
                fprintf(stderr, "RhinoParser Error: FAILURE in EndRead3dmObjectTable().\n");
            _continueReading = false;
            continue;
        }

        if (pObject) {  // object geted properly
            // when _parse_object() fails then the _pParsedObject attribute
            // keeps NULL and we can try to read next object
            pGeometry = ON_Geometry::Cast(pObject);
            if (pGeometry) _parse_object(*pGeometry, attributes);
            delete pObject;
            pObject = NULL;
        } else { // object skipped => try next one
            if (rc == 2)
                fprintf(stderr, "RhinoParser WARNING: Skipping object because it's filtered.\n");
            else if (rc == 3) 
                fprintf(stderr, "RhinoParser WARNING: Skipping object because it's newer than this code.  Update your OpenNURBS toolkit.\n");
            else 
                fprintf(stderr, "RhinoParser WARNING: Skipping object for unknown reason.\n");
        }
    }
      
    if (_pParsedObject) return true;
    else { _continueReading = false; return false; }
}

---