Java Double2D.distance方法代码示例

import sim.util.Double2D; //导入方法依赖的package包/类
/**
 * @param node
 * @param heads
 * @param base
 * @param rangeRadioDistance
 * @throws ShanksException
 */
private void moveInRange(ZigBeeSensorNode node, List<ZigBeeSensorNode> heads, ZigBeeSensorNode base,
		int rangeRadioDistance) throws ShanksException {
	Double2D closestPos = this.getClosestNodePosition(node, heads, base);
	Double2D originalPos = node.getPosition();
	double speed = ((double) rangeRadioDistance) / 5;
	Double2D currentPos = node.getPosition();
	double distance = currentPos.distance(closestPos);

	while (distance > rangeRadioDistance) {
		Double2D direction = closestPos.subtract(currentPos);
		direction = direction.normalize();
		Double2D movement = direction.multiply(speed);
		Double2D newPos = currentPos.add(movement);
		currentPos = newPos;
		distance = currentPos.distance(closestPos);
	}
	this.getLogger().finest(
			"Sensor moved: " + node.getID() + " -> Orignal Pos: " + originalPos.toString() + " / Final Pos: "
					+ currentPos.toString() + " / Target Pos: " + closestPos.toString());
	node.setPosition(currentPos);

}
 

import sim.util.Double2D; //导入方法依赖的package包/类
/**
 * @param windowLength
 * @param step
 * @param detectingSensors
 * @param distances
 */
private void countVotesForRegions(int windowLength, long step, HashMap<Resource, Double2D> detectingSensors,
		HashMap<Resource, Double> distances) {
	long initialTimestamp = step - windowLength / 2;
	long finalTimestamp = step + windowLength / 2;
	String query = "SELECT (?x as ?msg) WHERE { ?x a b2d2-wsn:ZigBeeMessage . ?x b2d2-wsn:isDetecting true . ?x b2d2-wsn:timestamp ?tmp FILTER (?tmp >= "
			+ initialTimestamp + " && ?tmp <= " + finalTimestamp + ") }";
	Query arqQuery = ARQFactory.get().createQuery(model, query);
	QueryExecution qExe = QueryExecutionFactory.create(arqQuery, model);
	ResultSet results = qExe.execSelect();
	List<String> alreadyVoted = new ArrayList<String>();
	while (results.hasNext()) {
		QuerySolution result = results.next();
		Resource resource = result.getResource("msg");
		String sensorName = resource.getProperty(Vocabulary.isSentBy).getProperty(Vocabulary.name).getString();
		if (!alreadyVoted.contains(sensorName)) {
			alreadyVoted.add(sensorName);
			Resource auxlocation = resource.getProperty(Vocabulary.isSentBy).getProperty(Vocabulary.locatedAt)
					.getResource();
			long auxX = auxlocation.getProperty(Vocabulary.longitude).getLong();
			long auxY = auxlocation.getProperty(Vocabulary.latitude).getLong();
			Double2D auxPosition = new Double2D(auxX, auxY);
			for (Entry<Resource, Double2D> entry : detectingSensors.entrySet()) {
				double distance = auxPosition.distance(entry.getValue());
				if (distances.containsKey(entry.getKey())) {
					double previous = distances.get(entry.getKey());
					distances.put(entry.getKey(), previous + distance);
				} else {
					distances.put(entry.getKey(), distance);
				}
			}
		}
	}
}
 

import sim.util.Double2D; //导入方法依赖的package包/类
/**
 * @param sensor
 * @param noise
 *            in dB
 * @return in mA
 */
public double getRequiredCurrentForEmissionToNode(ZigBeeSensorNode sensor, double noise) {
	Double2D pos1 = this.getPosition();
	Double2D pos2 = sensor.getPosition();
	double distance = pos1.distance(pos2);
	double distanceKm = distance / 1000;
	double loss = 100 + (20 * Math.log10(distanceKm)); // in dB for 2,4GHz
	double sensitivy = -90; // Sensitivity in dBm
	// Emission power required to ensure the reception (in dBm)
	double emisionPower = sensitivy + loss + noise;
	double emissionConsumption = Double.MAX_VALUE;

	// Consumption criteria (in mA) - (emissionPower in dBm)
	if (emisionPower < -24) {
		emissionConsumption = 7.3;
	} else if (emisionPower < -20) {
		emissionConsumption = 8.3;
	} else if (emisionPower < -18) {
		emissionConsumption = 8.8;
	} else if (emisionPower < -13) {
		emissionConsumption = 9.8;
	} else if (emisionPower < -10) {
		emissionConsumption = 10.4;
	} else if (emisionPower < -6) {
		emissionConsumption = 11.3;
	} else if (emisionPower < -2) {
		emissionConsumption = 15.6;
	} else if (emisionPower < 0) {
		emissionConsumption = 17.0;
	} else if (emisionPower < 3) {
		emissionConsumption = 20.2;
	} else if (emisionPower < 4) {
		emissionConsumption = 22.5;
	} else if (emisionPower < 5) {
		emissionConsumption = 26.9;
	}

	return emissionConsumption;
}
 

import sim.util.Double2D; //导入方法依赖的package包/类
/**
 * @param sensor
 * @param noise
 *            in dB
 * @return in mA
 */
public int getEmmitedPowerToNode(ZigBeeSensorNode sensor, double noise) {
	Double2D pos1 = this.getPosition();
	Double2D pos2 = sensor.getPosition();
	double distance = pos1.distance(pos2);
	double distanceKm = distance / 1000;
	double loss = 100 + (20 * Math.log10(distanceKm)); // in dB for 2,4GHz
	double sensitivy = -90; // Sensitivity in dBm
	// Emission power required to ensure the reception (in dBm)
	double emisionPower = sensitivy + loss + noise;
	int emittedPower = Integer.MAX_VALUE;

	// Consumption criteria (in mA) - (emissionPower in dBm)
	if (emisionPower < -24) {
		emittedPower = -24;
	} else if (emisionPower < -20) {
		emittedPower = -20;
	} else if (emisionPower < -18) {
		emittedPower = -18;
	} else if (emisionPower < -13) {
		emittedPower = -13;
	} else if (emisionPower < -10) {
		emittedPower = -10;
	} else if (emisionPower < -6) {
		emittedPower = -6;
	} else if (emisionPower < -2) {
		emittedPower = -2;
	} else if (emisionPower < 0) {
		emittedPower = 0;
	} else if (emisionPower < 3) {
		emittedPower = 3;
	} else if (emisionPower < 4) {
		emittedPower = 4;
	} else if (emisionPower < 5) {
		emittedPower = 5;
	}

	return emittedPower;
}
 

import sim.util.Double2D; //导入方法依赖的package包/类
/**
 * @param orig
 * @param alpha is the angle in the plane XY 
 * @return Double2D object
 */
public static Double2D rotate(Double2D orig, Double2D alpha) {
    Double moduleA = alpha.distance(origen2D);
    if (moduleA == 0) {
        return orig;
    } else {
        Double cosA = alpha.x / moduleA;
        Double sinA = alpha.y / moduleA;
        Double finalX = cosA * orig.x - sinA * orig.y;
        Double finalY = sinA * orig.x + cosA * orig.y;
        return new Double2D(finalX, finalY);
    }
}