Все нормально но при копированиии вылетает ошибка

void AsdkMkrEntity::crete_Triangulation(std::vector<hed::Node*>::iterator first,
                                        std::vector<hed::Node*>::iterator last)
{
    std::sort(first, last, ltLexPoint);
    std::vector<hed::Node*>::iterator new_end = std::unique(first, last, eqPoints);
    triang.createDelaunay(first, new_end);
    // Get a list of all edges in the triangulation, including boundary edges
    bool skip_boundary_edges = false;
    nodes_list = triang.getNodes();
    edges = triang.getEdges(skip_boundary_edges);
    acutPrintf( "nodes %d",nodes_list->size());
}
Acad::ErrorStatus
AsdkMkrEntity::dwgInFields(AcDbDwgFiler* filer)
{
  assertWriteEnabled();
  Acad::ErrorStatus es;
  // call dwgInFields from AcDbEntity
  //
  if ((es = AcDbEntity::dwgInFields(filer)) != Acad::eOk) {
    return es;
  }
  filer->readItem( &m_center );
  filer->readItem( &m_refId );
  Adesk::UInt32 version;
  filer->readItem(&version);
  if(version > VERSION_MY) return Acad::eMakeMeProxy;
  Adesk::UInt32 size;
  filer->readItem(&size);
  std::list<hed::Node*>::const_iterator nit;
    double x, y, z;
    nodes = new vector<hed::Node*>;
    // Loop through all the nodes in the list, and store the coordinates to file
    for (int i = 0; i < size; ++i) {
        filer->readItem(&x);
        filer->readItem(&y);
        filer->readItem(&z);
        nodes->push_back(new hed::Node(x, y, z));
    }
    Adesk::UInt32 num_constraints;
    num_constraints = 0;
    filer->readItem(&num_constraints);
    if (num_constraints > 0) {
    // Read the coordiantes of the source and destination nodes of the
    // constraints (x y z x y z)
        constraint_source_nodes = new vector<hed::Node*>;
        constraint_target_nodes = new vector<hed::Node*>;
        for (int i = 0; i < num_constraints; i++) {
            double x0, y0, z0;
            double x1, y1, z1;
            filer->readItem(&x0);
            filer->readItem(&y0);
            filer->readItem(&z0);
            filer->readItem(&x1);
            filer->readItem(&y1);
            filer->readItem(&z1);
        constraint_source_nodes->push_back(new hed::Node(x0, y0, z0));
        constraint_target_nodes->push_back(new hed::Node(x1, y1, z1));
        }
    }
    crete_Triangulation(nodes->begin(),nodes->end());
        if (constraint_source_nodes->size() > 0 &&
            constraint_source_nodes->size() == constraint_target_nodes->size())
        {
        // Insert the constraints
        vector<hed::Node*>::const_iterator it0;
        vector<hed::Node*>::const_iterator it1;
        // Two darts
        hed::Dart d0;
        hed::Dart d1;
        it1 = constraint_target_nodes->begin();
        for (it0 = constraint_source_nodes->begin();
            it0 != constraint_source_nodes->end();
            it0++)
        {
            // Find the node in the triangulation closest to the source
            // and destination point of the drawn constrained edge
//---------------------------------------------------------
            hed::Node point((*it0)->x(), (*it0)->y());
            hed::Dart dart = triang.createDart();
            // Check if the point are inside a triangle, and return a dart from the
            // triangle. Forefficiency reasons dart should be close to the point.
            if (!ttl::locateTriangle<hed::TTLtraits>(point, dart))
            {
                // There is no triangle that contains the given point.
                // Display error-message and return from function.
                acutPrintf( "Zaluppa vmesto constrein!!!");
            // Return an empty dart
            }
            else{
                d0 = dart;
            }
            hed::Node point1((*it1)->x(), (*it1)->y());
            hed::Dart dart1 = triang.createDart();
            if (!ttl::locateTriangle<hed::TTLtraits>(point1, dart1)) {
                acutPrintf( "Zaluppa vmesto constrein!!!");
            }
            else{
                d1 = dart1;
            }
            //d0 = findClosestNode((*it0)->x(), (*it0)->y());
            //d1 = findClosestNode((*it1)->x(), (*it1)->y());
//----------------------------------------------------------
            it1++;
            // Check that the nodes are inside the pick radius
            if (d0 == hed::Dart() || d1 == hed::Dart()) {
            // Dropp the constraint
            break;
            }
            // The triangulation should be a constrained Delaunay triangulation
            bool optimizeDelaunay = true;
            // Insert the constraint edge between the two existing nodes
            hed::Dart dart_cons;
            // NB! This fails if the inserted constraint crosses a constraint...
            dart_cons = ttl::insertConstraint<hed::TTLtraits>(d0, d1, optimizeDelaunay);
            if (dart_cons == hed::Dart()) {
            // The constraint edge was not inserted
            break;
            }
            else {
            // Mark the edge as constrained
            dart_cons.getEdge()->setConstrained();
            }
        }
        }
  return es;
}
Acad::ErrorStatus
AsdkMkrEntity::dwgOutFields(AcDbDwgFiler* filer) const
{
  assertReadEnabled();
  Acad::ErrorStatus es;
  // call dwgOutFields from AcDbEntity
  //
  if ((es = AcDbEntity::dwgOutFields(filer)) != Acad::eOk) {
    return es;
  }
  filer->writeItem( m_center );
  filer->writeItem( m_refId );
    
  filer->writeItem((Adesk::UInt32) VERSION_MY);
    // Save the number of nodes
    Adesk::UInt32 size = nodes_list->size();
    filer->writeItem(size);
    // Loop through all the nodes in the list, and store the coordinates to file
    std::list<hed::Node*>::const_iterator nit;
    for (nit = nodes_list->begin(); nit != nodes_list->end(); nit++) {
        filer->writeItem((*nit)->x());
        //acutPrintf( "x- %f",(*nit)->x());
        filer->writeItem((*nit)->y());
        //acutPrintf( "y- %f",(*nit)->y());
        filer->writeItem((*nit)->z());
        //acutPrintf( "z- %f\n",(*nit)->z());
    }
    std::vector<hed::Edge*>* constraints = new std::vector<hed::Edge*>;
    std::list<hed::Edge*>::const_iterator eit;
// Loop through all the edges in the list, and find the constraints
    for (eit = edges->begin(); eit != edges->end(); eit++) {
        if ((*eit)->isConstrained())
        {
            constraints->push_back(*eit);
        }
    }
    Adesk::UInt32 num_constraints = constraints->size();
    if (num_constraints > 0) {
        filer->writeItem(num_constraints);
        vector<hed::Edge*>::const_iterator cit;
    // Loop through all the constraints, and store the coordinates of
    // the source node and target node to file
        for (cit = constraints->begin(); cit != constraints->end(); cit++) {
            // Source node
            hed::Node* n0 = (*cit)->getSourceNode();
            filer->writeItem(n0->x());
            filer->writeItem(n0->y());
            filer->writeItem(n0->z());
            // Target node
            hed::Node* n1 = (*cit)->getTargetNode();
             filer->writeItem(n1->x());
            filer->writeItem(n1->y());
            filer->writeItem(n1->z());
        }
  }
  else{
      num_constraints = 0;
      filer->writeItem(num_constraints);
  }
    return es;
}