Commit 5f27f6f3 authored by Daniel Schramm's avatar Daniel Schramm
Browse files

Prioritized distance on sphere moved to separate visitor

parent a8f31cdb

Comparison/src/main/java/cz/fidentis/analyst/visitors/face/HausdorffDistancePrioritized.java

+6 −51
Original line number Diff line number Diff line
@@ -6,22 +6,15 @@ import cz.fidentis.analyst.feature.FeaturePointType; 
import cz.fidentis.analyst.kdtree.KdTree;

import cz.fidentis.analyst.mesh.core.MeshFacet;

import cz.fidentis.analyst.mesh.core.MeshModel;

import cz.fidentis.analyst.mesh.core.MeshPoint;

import cz.fidentis.analyst.visitors.mesh.HausdorffDistance;

import cz.fidentis.analyst.visitors.mesh.HausdorffDistance.Strategy;

import java.util.ArrayList;

import cz.fidentis.analyst.visitors.mesh.PrioritySphere;

import java.util.Collections;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.Future;

import java.util.logging.Level;

import java.util.logging.Logger;

import javax.vecmath.Point3d;



/**
@@ -33,8 +26,6 @@ public class HausdorffDistancePrioritized extends HumanFaceVisitor { 
    private final HausdorffDistance distanceVisitor;

    

    private final FeaturePointType featurePointType;

    // TODO TEMPORARY - needs to be computed dynamically

    private final double sphereRadius = 1;

    

    private final Map<MeshFacet, List<Double>> priorities = new HashMap<>();
@@ -95,51 +86,15 @@ public class HausdorffDistancePrioritized extends HumanFaceVisitor { 
    @Override

    public void visitHumanFace(HumanFace humanFace) {

        final FeaturePoint featurePoint = humanFace.getFeaturePoints().get(featurePointType.getType());

        final Point3d featurePointPosition = featurePoint.getPosition();

        

        final ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());

        

        final PrioritySphere priorityVisitor = new PrioritySphere(featurePoint.getPosition(), 1 /*TODO TEMPORARY - sphere radius needs to be computed dynamically*/);

        for (final MeshFacet comparedFacet: humanFace.getMeshModel().getFacets()) {

            comparedFacet.accept(distanceVisitor);

            

            final List<MeshPoint> vertices = comparedFacet.getVertices();

            

            final List<Future<Double>> results = new ArrayList<>(vertices.size());

            final List<Double> prioritiesList = new ArrayList<>(vertices.size());

            

            for (int i = 0; i < vertices.size(); i++) { // Taking vertices in the same order as 'distanceVisitor' does

                final Point3d vertexPosition = vertices.get(i).getPosition();

                if (inParallel() && isThreadSafe()) {

                    results.add(executor.submit(() -> computePriority(featurePointPosition, vertexPosition)));

                } else {

                    prioritiesList.add(computePriority(featurePointPosition, vertexPosition));

                }

            }

            

            if (inParallel() && isThreadSafe()) {

                executor.shutdown();

                while (!executor.isTerminated()){}

                try {

                    for (final Future<Double> priority: results) {

                        prioritiesList.add(priority.get());

                    }

                } catch (final InterruptedException | ExecutionException ex) {

                    Logger.getLogger(HausdorffDistancePrioritized.class.getName()).log(Level.SEVERE, null, ex);

                }

            comparedFacet.accept(priorityVisitor);

        }

        

        synchronized(this) {

                priorities.put(comparedFacet, prioritiesList);

            }

        }

            priorities.putAll(priorityVisitor.getPriorities());

        }

    

    protected double computePriority(Point3d featurePointPosition, Point3d vertexPosition) {

        final double distance = featurePointPosition.distance(vertexPosition);

        if (distance > sphereRadius) {

            return 0;

        }

        

        return 1 - distance / sphereRadius;

    }

}

Comparison/src/main/java/cz/fidentis/analyst/visitors/mesh/PrioritySphere.java

0 → 100644
+55 −0
Original line number Diff line number Diff line 
package cz.fidentis.analyst.visitors.mesh;



import cz.fidentis.analyst.mesh.MeshVisitor;

import cz.fidentis.analyst.mesh.core.MeshFacet;

import cz.fidentis.analyst.mesh.core.MeshPoint;

import java.util.ArrayList;

import java.util.Collections;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import javax.vecmath.Point3d;



/**

 *

 * @author Daniel Schramm

 */

public class PrioritySphere extends MeshVisitor  {

    

    private final Point3d featurePointPosition;

    private final double sphereRadius;

    

    private final Map<MeshFacet, List<Double>> priorities = new HashMap<>();



    public PrioritySphere(Point3d featurePointPosition, double sphereRadius) {

        if (featurePointPosition == null) {

            throw new IllegalArgumentException("featurePointPosition");

        }

        this.featurePointPosition = featurePointPosition;

        this.sphereRadius = sphereRadius;

    }



    public Map<MeshFacet, List<Double>> getPriorities() {

        return Collections.unmodifiableMap(priorities);

    }



    @Override

    public void visitMeshFacet(MeshFacet facet) {

        final List<MeshPoint> vertices = facet.getVertices();

        

        for (int i = 0; i < vertices.size(); i++) {

            final double distance = featurePointPosition.distance(vertices.get(i).getPosition());

            final double priority;

            if (distance > sphereRadius) {

                priority = 0;

            } else {

                priority = 1 - distance / sphereRadius;

            }

            

            synchronized(this) {

                priorities.computeIfAbsent(facet, meshFacet -> new ArrayList<>())

                        .add(priority);

            }

        }

    }

}