File |
Line |
org\opentrafficsim\core\geometry\OTSBufferingJTS.java |
325 |
org\opentrafficsim\core\geometry\OTSLine3D.java |
329 |
ArrayList<Coordinate> out = new ArrayList<Coordinate>();
Coordinate[] firstCoordinates = startGeometry.getCoordinates();
Coordinate[] secondCoordinates = endGeometry.getCoordinates();
int firstIndex = 0;
int secondIndex = 0;
Coordinate prevCoordinate = null;
final double tooClose = 0.05; // 5 cm
while (firstIndex < firstCoordinates.length && secondIndex < secondCoordinates.length)
{
double firstRatio = firstIndex < firstCoordinates.length ? first.indexOf(firstCoordinates[firstIndex]) / firstLength
: Double.MAX_VALUE;
double secondRatio = secondIndex < secondCoordinates.length
? second.indexOf(secondCoordinates[secondIndex]) / secondLength : Double.MAX_VALUE;
double ratio;
if (firstRatio < secondRatio)
{
ratio = firstRatio;
firstIndex++;
}
else
{
ratio = secondRatio;
secondIndex++;
}
Coordinate firstCoordinate = first.extractPoint(ratio * firstLength);
Coordinate secondCoordinate = second.extractPoint(ratio * secondLength);
Coordinate resultCoordinate = new Coordinate((1 - ratio) * firstCoordinate.x + ratio * secondCoordinate.x,
(1 - ratio) * firstCoordinate.y + ratio * secondCoordinate.y);
if (null == prevCoordinate || resultCoordinate.distance(prevCoordinate) > tooClose)
{
out.add(resultCoordinate);
prevCoordinate = resultCoordinate;
}
}
Coordinate[] resultCoordinates = new Coordinate[out.size()];
for (int index = 0; index < out.size(); index++)
{
resultCoordinates[index] = out.get(index);
}
return new OTSLine3D(resultCoordinates);
} |
File |
Line |
org\opentrafficsim\core\geometry\OTSBufferingJTS.java |
269 |
org\opentrafficsim\core\geometry\OTSPoint3D.java |
176 |
private static OTSPoint3D intersectionOfLineSegments(final OTSPoint3D line1P1, final OTSPoint3D line1P2,
final OTSPoint3D line2P1, final OTSPoint3D line2P2)
{
double denominator =
(line2P2.y - line2P1.y) * (line1P2.x - line1P1.x) - (line2P2.x - line2P1.x) * (line1P2.y - line1P1.y);
if (denominator == 0f)
{
return null; // lines are parallel (they might even be on top of each other, but we don't check that)
}
double uA = ((line2P2.x - line2P1.x) * (line1P1.y - line2P1.y) - (line2P2.y - line2P1.y) * (line1P1.x - line2P1.x))
/ denominator;
if ((uA < 0f) || (uA > 1f))
{
return null; // intersection outside line 1
}
double uB = ((line1P2.x - line1P1.x) * (line1P1.y - line2P1.y) - (line1P2.y - line1P1.y) * (line1P1.x - line2P1.x))
/ denominator;
if (uB < 0 || uB > 1)
{
return null; // intersection outside line 2
}
return new OTSPoint3D(line1P1.x + uA * (line1P2.x - line1P1.x), line1P1.y + uA * (line1P2.y - line1P1.y), 0);
}
/**
* Create a line at linearly varying offset from a reference line. The offset may change linearly from its initial value at
* the start of the reference line to its final offset value at the end of the reference line.
* @param referenceLine OTSLine3D; the Geometry of the reference line
* @param offsetAtStart double; offset at the start of the reference line (positive value is Left, negative value is Right)
* @param offsetAtEnd double; offset at the end of the reference line (positive value is Left, negative value is Right)
* @return Geometry; the Geometry of the line at linearly changing offset of the reference line
* @throws OTSGeometryException when this method fails to create the offset line
*/
public static OTSLine3D offsetLine(final OTSLine3D referenceLine, final double offsetAtStart, final double offsetAtEnd) |
File |
Line |
org\opentrafficsim\core\dsol\OTSDEVSRTParallelMove.java |
302 |
org\opentrafficsim\core\dsol\OTSDEVSRTParallelMove.java |
345 |
new SimEvent<>(this.simulatorTime, se.getSource(), se.getTarget(), "movePrep", se.getArgs());
this.executor.execute(new Runnable()
{
@Override
public void run()
{
try
{
moveEvent.execute();
}
catch (Exception exception)
{
getLogger().always().error(exception);
if (OTSDEVSRTParallelMove.this.isPauseOnError())
{
try
{
OTSDEVSRTParallelMove.this.stop();
}
catch (SimRuntimeException exception1)
{
getLogger().always().error(exception1);
}
}
}
}
});
}
this.executor.shutdown();
try
{
this.executor.awaitTermination(1L, java.util.concurrent.TimeUnit.HOURS);
}
catch (InterruptedException exception)
{
//
}
this.executor = Executors.newFixedThreadPool(1);
for (int i = 0; i < moveEvents.size(); i++)
{
SimEvent<SimTimeDoubleUnit> se = (SimEvent<SimTimeDoubleUnit>) moveEvents.get(i);
final SimEventInterface<SimTimeDoubleUnit> moveEvent =
new SimEvent<>(this.simulatorTime, se.getSource(), se.getTarget(), "moveGenerate", se.getArgs()); |
File |
Line |
org\opentrafficsim\core\geometry\OTSBufferingJTS.java |
332 |
org\opentrafficsim\core\geometry\OTSLine3D.java |
336 |
org\opentrafficsim\core\geometry\OTSLine3D.java |
429 |
while (firstIndex < firstCoordinates.length && secondIndex < secondCoordinates.length)
{
double firstRatio = firstIndex < firstCoordinates.length ? first.indexOf(firstCoordinates[firstIndex]) / firstLength
: Double.MAX_VALUE;
double secondRatio = secondIndex < secondCoordinates.length
? second.indexOf(secondCoordinates[secondIndex]) / secondLength : Double.MAX_VALUE;
double ratio;
if (firstRatio < secondRatio)
{
ratio = firstRatio;
firstIndex++;
}
else
{
ratio = secondRatio;
secondIndex++;
}
Coordinate firstCoordinate = first.extractPoint(ratio * firstLength);
Coordinate secondCoordinate = second.extractPoint(ratio * secondLength);
Coordinate resultCoordinate = new Coordinate((1 - ratio) * firstCoordinate.x + ratio * secondCoordinate.x,
(1 - ratio) * firstCoordinate.y + ratio * secondCoordinate.y);
if (null == prevCoordinate || resultCoordinate.distance(prevCoordinate) > tooClose)
{
out.add(resultCoordinate);
prevCoordinate = resultCoordinate;
}
} |
File |
Line |
org\opentrafficsim\core\dsol\OTSAnimator.java |
70 |
org\opentrafficsim\core\dsol\OTSLoggingAnimator.java |
71 |
public void initialize(final Time startTime, final Duration warmupPeriod, final Duration runLength,
final OTSModelInterface model, final Map<String, StreamInterface> streams)
throws SimRuntimeException, NamingException
{
setPauseOnError(true);
setAnimationDelay(20); // 50 Hz animation update
OTSReplication newReplication =
OTSReplication.create("rep" + ++this.lastReplication, startTime, warmupPeriod, runLength, model);
newReplication.getStreams().putAll(streams);
super.initialize(newReplication, ReplicationMode.TERMINATING);
}
/** {@inheritDoc} */
@Override
public void initialize(final Time startTime, final Duration warmupPeriod, final Duration runLength,
final OTSModelInterface model, final int replicationnr) throws SimRuntimeException, NamingException
{
setPauseOnError(true);
setAnimationDelay(20); // 50 Hz animation update
OTSReplication newReplication = OTSReplication.create("rep" + replicationnr, startTime, warmupPeriod, runLength, model);
super.initialize(newReplication, ReplicationMode.TERMINATING);
}
/** {@inheritDoc} */
@Override
public final SimEvent<SimTimeDoubleUnit> scheduleEvent(final Time executionTime, final short priority, final Object source, |
File |
Line |
org\opentrafficsim\core\dsol\OTSDEVSRTParallelMove.java |
302 |
org\opentrafficsim\core\dsol\OTSDEVSRTParallelMove.java |
345 |
org\opentrafficsim\core\dsol\OTSDEVSRTParallelMove.java |
388 |
new SimEvent<>(this.simulatorTime, se.getSource(), se.getTarget(), "movePrep", se.getArgs());
this.executor.execute(new Runnable()
{
@Override
public void run()
{
try
{
moveEvent.execute();
}
catch (Exception exception)
{
getLogger().always().error(exception);
if (OTSDEVSRTParallelMove.this.isPauseOnError())
{
try
{
OTSDEVSRTParallelMove.this.stop();
}
catch (SimRuntimeException exception1)
{
getLogger().always().error(exception1);
}
}
}
}
});
}
this.executor.shutdown();
try
{
this.executor.awaitTermination(1L, java.util.concurrent.TimeUnit.HOURS);
}
catch (InterruptedException exception)
{
//
} |
File |
Line |
org\opentrafficsim\core\dsol\OTSAnimator.java |
89 |
org\opentrafficsim\core\dsol\OTSSimulator.java |
58 |
OTSReplication newReplication = OTSReplication.create("rep" + replicationnr, startTime, warmupPeriod, runLength, model);
super.initialize(newReplication, ReplicationMode.TERMINATING);
}
/** {@inheritDoc} */
@Override
public final SimEvent<SimTimeDoubleUnit> scheduleEvent(final Time executionTime, final short priority, final Object source,
final Object target, final String method, final Object[] args) throws SimRuntimeException
{
SimEvent<SimTimeDoubleUnit> result =
new SimEvent<>(new SimTimeDoubleUnit(new Time(executionTime.getSI(), TimeUnit.DEFAULT)), priority, source,
target, method, args);
scheduleEvent(result);
return result;
}
/** {@inheritDoc} */
@Override
public final OTSReplication getReplication() |
File |
Line |
org\opentrafficsim\core\geometry\OTSBufferingJTS.java |
179 |
org\opentrafficsim\core\geometry\OTSOffsetLinePK.java |
149 |
for (int additionalPoint = 1; additionalPoint < numSegments; additionalPoint++)
{
double intermediateAngle =
(additionalPoint * angle + (numSegments - additionalPoint) * prevAngle) / numSegments;
if (prevAngle * angle < 0 && Math.abs(prevAngle) > Math.PI / 2 && Math.abs(angle) > Math.PI / 2)
{
intermediateAngle += Math.PI;
}
OTSPoint3D intermediatePoint = new OTSPoint3D(prevPoint.x - Math.sin(intermediateAngle) * offset,
prevPoint.y + Math.cos(intermediateAngle) * offset); |
File |
Line |
org\opentrafficsim\core\network\OTSNode.java |
179 |
org\opentrafficsim\core\network\OTSNode.java |
242 |
}
// ------------------------------------------- make datasets if needed
if (this.connections == null)
{
this.connections = new LinkedHashMap<>();
}
if (!this.connections.containsKey(gtuType))
{
this.connections.put(gtuType, new LinkedHashMap<>());
}
Map<Link, Set<Link>> gtuMap = this.connections.get(gtuType);
if (!gtuMap.containsKey(incomingLink))
{
gtuMap.put(incomingLink, new LinkedHashSet<>());
}
// ------------------------------------------- add the connection
gtuMap.get(incomingLink).add(outgoingLink); |
File |
Line |
org\opentrafficsim\core\perception\collections\HistoricalHashMap.java |
42 |
org\opentrafficsim\core\perception\collections\HistoricalLinkedHashMap.java |
42 |
public HistoricalHashMap(final HistoryManager historyManager, final Map<? extends K, ? extends V> m)
{
super(historyManager, new LinkedHashMap<>(m));
}
/** {@inheritDoc} */
@Override
public LinkedHashMap<K, V> get()
{
return getMap();
}
/** {@inheritDoc} */
@Override
public LinkedHashMap<K, V> get(final Time time)
{
if (isLastState(time))
{
return getMap();
}
return fill(time, new LinkedHashMap<>());
}
/** {@inheritDoc} */
@Override
public String toString()
{
return "HistoricalHashMap [current=" + getMap() + "]"; |