chart.cpp

开源的电子海图程序

        std::cerr << "Chart::S57ReadDSPMRecord(): DSPM already loaded"
                  << std::endl;
        return -1;
    }
    if (dspm.Load(record) < 0) {
        std::cerr << "Chart::S57ReadDSPMRecord(): Error loading dspm record"
                  << std::endl;
        return -1;
    }
    dspm_loaded = true;
    return 0;
}

//*****************************************************************************
//
// Feature record loading
//
//*****************************************************************************

/**
 * Read feature data from a record.
 * @param record The record to read
 * @return 0 on success, -1 on failure.
 */
int Chart::S57ReadFeatureRecord(DDFRecord *record)
{
    DDFField *field = record->GetField(1);
    if (!field)
        return -1;
            
    DDFFieldDefn *field_defn = field->GetFieldDefn();
    if (!field_defn)
        return -1;

    const char *field_data = field->GetData();
    if (!field_data)
        return -1;

    int bytes_remaining = field->GetDataSize();
    int bytes_consumed = 0;

    DDFSubfieldDefn *subfield_defn;
    subfield_defn = field_defn->GetSubfield(2);
    if (!subfield_defn)
        return -1;

    // skip rcnm, rcid
    for (int i = 0; i < 2; i++) {
        subfield_defn = field_defn->GetSubfield(i);
        if (!subfield_defn)
            return -1;
        subfield_defn->ExtractIntData(field_data, bytes_remaining,
                                            &bytes_consumed);
        bytes_remaining -= bytes_consumed;
        field_data += bytes_consumed;
    }

    subfield_defn = field_defn->GetSubfield(2);
    if (!subfield_defn)
        return -1;
    int prim = subfield_defn->ExtractIntData(field_data, bytes_remaining,
                                            &bytes_consumed);

    switch (prim)
    {
        case 1:
            if (S57LoadPointFeature(record) < 0) {
                std::cerr << "Chart::S57ReadFeatureRecord(): "
                          << "Error loading point feature" << std::endl;
                return -1;
            }
            break;
        case 2:
            if (S57LoadLineFeature(record) < 0) {
                std::cerr << "Chart::S57ReadFeatureRecord(): "
                          << "Error loading line feature" << std::endl;
                return -1;
            }
            break;
        case 3:
            if (S57LoadAreaFeature(record) < 0) {
                std::cerr << "Chart::S57ReadFeatureRecord(): "
                          << "Error loading area feature" << std::endl;
                return -1;
            }
            break;
        case 255:
            break;
        default:
            std::cerr << "Chart::S57ReadFeatureRecord(): Unknown prim"
                      << prim << std::endl;
            return -1;
    }

    return 0;
}

/**
 * Read point feature data from a record
 * @param record The record to read
 * @return 0 on success, -1 on failure.
 */
int Chart::S57LoadPointFeature(DDFRecord *record)
{
    PointFeature point_feature;
    int result;
    if ((result = point_feature.Load(record)) < 0) {
        std::cerr << "Chart::S57LoadPointFeature(): Error loading" << std::endl;
        return -1;
    }
    
    point_features_map[result].push_back(point_feature);

    return 0;
}

/**
 * Read line feature data from a record
 * @param record The record to read
 * @return 0 on success, -1 on failure.
 */
int Chart::S57LoadLineFeature(DDFRecord *record)
{
    LineFeature line_feature;
    int result;
    if ((result = line_feature.Load(record)) < 0) {
        std::cerr << "Chart::S57LoadLineFeature(): Error loading" << std::endl;
        return -1;
    }

    line_features_map[result].push_back(line_feature);

    return 0;
}

/**
 * Read area feature data from a record
 * @param record The record to read
 * @return 0 on success, -1 on failure.
 */
int Chart::S57LoadAreaFeature(DDFRecord *record)
{
    AreaFeature area_feature;
    int result;
    if ((result = area_feature.Load(record)) < 0) {
        std::cerr << "Chart::S57LoadAreaFeature(): Error loading" << std::endl;
        return -1;
    }

    area_features_map[result].push_back(area_feature);

    return 0;
}

//*****************************************************************************
//
// Vector record loading
//
//*****************************************************************************

/**
 * Read vector data from  a record
 * @param record The record to read
 * @return -1 on failure, 0 on success.
 */
int Chart::S57ReadVectorRecord(DDFRecord *record)
{
    DDFField *field = record->GetField(1);
    if (!field)
        return -1;
    DDFFieldDefn *field_defn = field->GetFieldDefn();
    if (!field_defn)
        return -1;
    const char *field_data = field->GetData();
    if (!field_data)
        return -1;
    int bytes_remaining = field->GetDataSize();
    int bytes_consumed = 0;

    DDFSubfieldDefn *subfield_defn;

    subfield_defn = field_defn->GetSubfield(0);
    if (!subfield_defn)
        return -1;
    int rcnm = subfield_defn->ExtractIntData(field_data, bytes_remaining,
                                            &bytes_consumed);

    switch (rcnm)
    {
        case 110:
            if (S57LoadIsolatedNodeVectorRecord(record) < 0) {
                std::cerr << "Chart::S57ReadVectorRecord(): "
                          << "Error loading isolated node vector" << std::endl;
                return -1;
            }
            break;
        case 120:
            if (S57LoadConnectedNodeVectorRecord(record) < 0) {
                std::cerr << "Chart::S57ReadVectorRecord(): "
                          << "Error connected node vector" << std::endl;
                return -1;
            }
            break;
        case 130:
            if (S57LoadEdgeVectorRecord(record) < 0) {
                std::cerr << "Chart::S57ReadVectorRecord(): "
                          << "Error loading edge vector" << std::endl;
                return -1;
            }
            break;
        case 140:
            break;
        default:
            std::cerr << "Chart::S57ReadVectorRecord(): Unknown rcnm"
                      << rcnm << std::endl;
            return -1;
    }

    return 0;
}

/**
 * Read isolated node vector data from a record
 * @param record The record to read
 * @return -1 on failure, 0 on success.
 */
int Chart::S57LoadIsolatedNodeVectorRecord(DDFRecord *record)
{
    IsolatedNodeVector isolated_node_vector;
    int record_id;
    if ((record_id = isolated_node_vector.Load(record)) < 0) {
        std::cerr << "Chart::S57LoadIsolatedNodeVectorRecord(): Error loading"
                  << std::endl;
        return -1;
    }

    isolated_node_vectors_map[record_id] = isolated_node_vector;

    return 0;
}

/**
 * Read connected node vector data from a record
 * @param record The record to read
 * @return -1 on failure, 0 on success.
 */
int Chart::S57LoadConnectedNodeVectorRecord(DDFRecord *record)
{
    ConnectedNodeVector connected_node_vector;
    int record_id;
    if ((record_id = connected_node_vector.Load(record)) < 0) {
        std::cerr << "Chart::S57LoadConnectedNodeVectorRecord(): Error loading"
                  << std::endl;
        return -1;
    }

    connected_node_vectors_map[record_id] = connected_node_vector;

    return 0;
}

/**
 * Read edge node vector data from a record
 * @param record The record to read
 * @return -1 on failure, 0 on success.
 */
int Chart::S57LoadEdgeVectorRecord(DDFRecord *record)
{
    EdgeVector edge_vector;
    int record_id;
    if ((record_id = edge_vector.Load(record)) < 0) {
        std::cerr << "Chart::S57LoadEdgeVectorRecord(): Error loading"
                  << std::endl;
        return -1;
    }

    edge_vectors_map[record_id] = edge_vector;

    return 0;
}


//*****************************************************************************
//
// Setup of edges, areas, display lists
//
//*****************************************************************************

/**
 * Multiply all coordinates by the normalization factor. 
 */
void Chart::S57NormalizeCoordinates()
{
    int coord_mult_factor = dspm.GetCoordMultFactor();

    std::map<int, EdgeVector>::iterator ev;
    std::map<int, EdgeVector>::iterator edge_end(edge_vectors_map.end());
    for (ev = edge_vectors_map.begin(); ev != edge_end; ++ev)
        ev->second.Normalize(coord_mult_factor);

    std::map<int, IsolatedNodeVector>::iterator inv;
    std::map<int, IsolatedNodeVector>::iterator
                                iso_end(isolated_node_vectors_map.end());
    for (inv = isolated_node_vectors_map.begin(); inv != iso_end; ++inv) 
        inv->second.Normalize(coord_mult_factor);
}

/**
 * Complete edge vectors
 * @return -1 on failure, 0 on success
 */
int Chart::S57SetupEdgeVectors()
{ 

    std::map<int, EdgeVector>::iterator pos;
    std::map<int, EdgeVector>::iterator end(edge_vectors_map.end());
    for (pos = edge_vectors_map.begin(); pos != end; ++pos)
        pos->second.CompleteEdge(connected_node_vectors_map);

    return 0;
}

/**
 * Setup area features
 * @return 0 on success, -1 on failure
 */
int Chart::S57SetupAreaFeatures()
{
    std::map<int, std::vector<AreaFeature> >::iterator af;
    std::map<int, std::vector<AreaFeature> >::iterator end = 
                                               area_features_map.end();
    for (af = area_features_map.begin(); af != end; ++af) {
        int area_count = af->second.size();
        for (int i = 0; i < area_count; i++)
            af->second[i].CompleteContours(edge_vectors_map);
    }

    return 0;
}