alchemist-incarnation-biochemistry/it.unibo.alchemist.model.biochemistry.environments/BioRect2DEnvironmentNoOverlap

BioRect2DEnvironmentNoOverlap

class BioRect2DEnvironmentNoOverlap : BioRect2DEnvironment, EnvironmentSupportingDeformableCells<Euclidean2DPosition> (source)

Implements a limited environment supporting cells with a defined shape, avoiding any overlapping among them.

Constructors

constructor(incarnation: BiochemistryIncarnation)

Returns an infinite BioRect2DEnvironment.

constructor(incarnation: BiochemistryIncarnation, minX: Double, maxX: Double, minY: Double, maxY: Double)

Returns a limited rectangular BioRect2DEnvironment.

Properties

dimensions

val dimensions: Int

incarnation

val incarnation: Incarnation<T, P>

networkModel

open var networkModel: NetworkModel<T>

shapeFactory

val shapeFactory: Euclidean2DShapeFactory

simulationOrNull

open val simulationOrNull: Simulation<T, P>

Functions

addLayer

open fun addLayer(molecule: Molecule, layer: Layer<T, P>)

addNode

open fun addNode(node: Node<T>, position: P): Boolean

addReaction

open fun addReaction(reaction: Reaction<T>)

addTerminator

open fun addTerminator(terminator: TerminationPredicate<T, P>)

contains

open fun contains(node: Node<T>): Boolean

currentPositionOf

open fun currentPositionOf(node: Node<T>): P

distanceBetween

open fun distanceBetween(n1: Node<T>, n2: Node<T>): Double

distanceTo

open fun distanceTo($this$distanceTo: Node<T>, other: Node<T>): Double

farthestReachablePosition

@Nonnull

open fun farthestReachablePosition(@Nonnull node: Node<Double>, @Nonnull desired: Euclidean2DPosition): Euclidean2DPosition

Circular cells stop before overlapping other circular cells, within the limits of the environment.

open fun farthestReachablePosition(node: Node<T>, desired: P): P

open fun farthestReachablePosition(node: Node<T>, desired: Euclidean2DPosition): Euclidean2DPosition

getCurrentPosition

open fun getCurrentPosition($this$currentPosition: Node<T>): P

getHeading

abstract fun getHeading(p: Node<T>): P

open fun getHeading(node: Node<T>): Euclidean2DPosition

getLayers

fun getLayers(): Map<Molecule, Layer<T, P>>

getMaxDiameterAmongCircularDeformableCells

@Nonnull

open fun getMaxDiameterAmongCircularDeformableCells(): Observable<Double>

The biggest diameter among the unstressed deformable cells, or zero if there are none.

getNeighborhood

open fun getNeighborhood($this$neighborhood: Node<T>): Observable<Neighborhood<T>>

getNodeCount

fun getNodeCount(): Observable<Integer>

getNodes

open fun getNodes(): ObservableList<Node<T>>

getNodesWithin

open fun getNodesWithin(shape: Shape<Euclidean2DPosition, Euclidean2DTransformation>): List<Node<T>>

getOffset

fun getOffset(): Array<Double>

getOrigin

open fun getOrigin(): P

open fun getOrigin(): Euclidean2DPosition

getPosition

open fun getPosition($this$position: Node<T>): Observable<P>

getReactions

open fun getReactions(): ObservableList<Reaction<T>>

getShape

abstract fun getShape(p: Node<T>): Shape<P, A>

open fun getShape(node: Node<T>): Shape<Euclidean2DPosition, Euclidean2DTransformation>

getShapeFactory

abstract fun getShapeFactory(): F

getSimulation

fun getSimulation(): Simulation<T, P>

getSize

fun getSize(): Array<Double>

getSizeInDistanceUnits

open fun getSizeInDistanceUnits(): Array<Double>

isTerminated

open fun isTerminated(): Boolean

layerFor

open fun layerFor(molecule: Molecule): Layer<T, P>

makePosition

open fun makePosition(coordinates: List<out Number>): P

open fun makePosition(coordinates: Array<Number>): Euclidean2DPosition

moveBy

open fun moveBy($this$moveBy: Node<T>, displacement: Euclidean2DPosition)

moveNodeBy

open fun moveNodeBy(node: Node<T>, displacement: Euclidean2DPosition)

moveNodeTo

open fun moveNodeTo(node: Node<Double>, position: Euclidean2DPosition)

Only cells move. After a cell moves, its junctions with nodes that are no longer neighbors are removed.

open fun moveNodeTo(node: Node<T>, position: P)

moveTo

open fun moveTo($this$moveTo: Node<T>, position: P)

neighborhoodOf

open fun neighborhoodOf(node: Node<T>): Observable<Neighborhood<T>>

nodesAround

open fun nodesAround(node: Node<T>, range: Double): List<Node<T>>

nodesInRange

open fun nodesInRange($this$nodesInRange: Node<T>, range: Double): List<Node<T>>

nodeWithId

open fun nodeWithId(id: Int): Node<T>

observeLayerValue

open fun observeLayerValue(molecule: Molecule, node: Node<T>): Observable<T>

observeNodesAround

open fun observeNodesAround(node: Node<T>, range: Double): ObservableSet<Node<T>>

observeNodesInRange

open fun observeNodesInRange($this$observeNodesInRange: Node<T>, range: Double): ObservableSet<Node<T>>

positionOf

open fun positionOf(node: Node<T>): Observable<P>

remove

open fun remove($this$remove: Node<T>)

removeNode

open fun removeNode(node: Node<T>)

removeReaction

open fun removeReaction(reaction: Reaction<T>)

setHeading

open fun setHeading(node: Node<T>, direction: Euclidean2DPosition)

setSimulation

fun setSimulation(value: Simulation<T, P>)

toPosition

open fun toPosition($this$toPosition: Array<Double>): P

toString

open fun toString(): String