ClusterableFragment.java

Go to the documentation of this file.

package denoptim.fragmenter;
 
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Set;
 
import javax.vecmath.Point3d;
 
import org.apache.commons.math3.ml.clustering.Clusterable;
import org.jgrapht.graph.DefaultUndirectedGraph;
import org.openscience.cdk.interfaces.IAtom;
 
import denoptim.constants.DENOPTIMConstants;
import denoptim.graph.AttachmentPoint;
import denoptim.graph.FragIsomorphEdge;
import denoptim.graph.FragIsomorphNode;
import denoptim.graph.Fragment;
 
public class ClusterableFragment implements Clusterable
{
    private Fragment frag;
    
    private List<FragIsomorphNode> orderedNodes;
    
    double[] allCoords;
    
//------------------------------------------------------------------------------
    
    public ClusterableFragment(Fragment frag)
    {
        this.frag = frag;
    }
 
//------------------------------------------------------------------------------
    
    public void setOrderOfNodes(Collection<FragIsomorphNode> c)
    {
        orderedNodes = new ArrayList<FragIsomorphNode>(c);
        
        allCoords = new double[orderedNodes.size()*3];
        int i=-1;
        for (FragIsomorphNode node : orderedNodes)
        {
            i++;
            allCoords[i] = node.getPoint3d().x;
            i++;
            allCoords[i] = node.getPoint3d().y;
            i++;
            allCoords[i] = node.getPoint3d().z;
        }
    }
    
//------------------------------------------------------------------------------
    
    public void setNaturalNodeOrder()
    {
        List<FragIsomorphNode> naturalOrder = new ArrayList<FragIsomorphNode>();
        Set<FragIsomorphNode> nodeSet = 
                frag.getJGraphFragIsomorphism().vertexSet();
        for (IAtom atm : frag.atoms())
        {
            for (FragIsomorphNode n : nodeSet)
            {
                if (n.getOriginal() == atm)
                {
                    naturalOrder.add(n);
                    break;
                }
            }
        }
        for (AttachmentPoint ap : frag.getAttachmentPoints())
        {
            for (FragIsomorphNode n : nodeSet)
            {
                if (n.getOriginal() == ap)
                {
                    naturalOrder.add(n);
                    break;
                }
            }
        }
        setOrderOfNodes(naturalOrder);
    }
    
//------------------------------------------------------------------------------
    
    protected void setCoordsVector(double[] coords)
    {
        this.allCoords = coords;
    }
    
//------------------------------------------------------------------------------
    
    protected void setCoordsVector(Point3d[] pts)
    {
        this.allCoords = convertToCoordsVector(pts);
    }
    
//------------------------------------------------------------------------------
    
    protected Fragment getOriginalFragment()
    {
        return frag;
    }
 
//------------------------------------------------------------------------------
    
    protected DefaultUndirectedGraph<FragIsomorphNode, FragIsomorphEdge> 
        getJGraphFragIsomorphism()
    {
        return frag.getJGraphFragIsomorphism();
    }
 
//------------------------------------------------------------------------------
    
    @Override
    public double[] getPoint()
    {       
        return allCoords;
    }
    
//------------------------------------------------------------------------------
    
    public List<FragIsomorphNode> getOrderedNodes()
    {
        return orderedNodes;
    }
 
//------------------------------------------------------------------------------
    
    public static double[] convertToCoordsVector(Point3d[] pts)
    {
        double[] coords = new double[pts.length*3];
        for (int j=0; j<pts.length; j++)
        {
            int i = j*3;
            coords[i] = pts[j].x;
            coords[i+1] = pts[j].y;
            coords[i+2] = pts[j].z;
        }
        return coords;
    }
    
//------------------------------------------------------------------------------
    
    public static Point3d[] convertToPointArray(double[] coords)
    {
        Point3d[] pts = new Point3d[coords.length/3];
        for (int j=0; j<coords.length/3; j++)
        {
            int i = j*3;
            pts[j] = new Point3d(coords[i], coords[i+1], coords[i+2]);
        }
        return pts;
    }
    
//------------------------------------------------------------------------------
    
    @Override
    public ClusterableFragment clone()
    {
        ClusterableFragment clone = new ClusterableFragment(this.frag);
        clone.setOrderOfNodes(orderedNodes);
        return clone;
    }
    
//------------------------------------------------------------------------------
 
    public Fragment getTransformedCopy()
    {
        Fragment copy = frag.clone();
        
        Point3d[] newCoords = ClusterableFragment.convertToPointArray(allCoords);
        int j=0;
        for (FragIsomorphNode node : this.orderedNodes)
        {
            if (node.isAtm())
            {
                int atmId = frag.indexOf((IAtom) node.getOriginal());
                copy.getAtom(atmId).setPoint3d(newCoords[j]);
            } else {
                int apId = frag.getIndexOfAP((AttachmentPoint) node.getOriginal());
                copy.getAP(apId).setDirectionVector(newCoords[j]);
            }
            j++;
        }
        return copy;
    }
 
//------------------------------------------------------------------------------
    
}