intersections = intersections(p0, p1, circleCenter, circleRadius); for(PVector i : intersections) { circle(i.x, i.y, 10); }` | `drawer.circles( line.intersections(cir), 10.0)` |
| subtract two vectors | `PVector d = PVector.sub(end, start);` | `val d = end - start` |
| check if variable in given range | `if (t1 >= 0 && t1 <= 1)` | `if (t1 in 0.0..1.0)` |
| linear interpolation between two vectors | `PVector.lerp(start, end, pos)` | `mix(start, end, pos)` |
I like that in OPENRNDR vector data types (representing points in 2D, 3D or 4D) can be used to define shapes, draw them, set colors, call noise functions, etc. For example you can do `line(p1, p2)` instead of `line(p1.x, p1.y, p2.x, p2.y)`. Those same vectors can easily be combined using `+`, `-`, `*`, `/` to write very readable expressions, for example `line(p1+p2, p1-p2)`, where `p1` and `p2` are 2D points.
Note: if you are wondering where do `start` and `end` come from in the OPENRNDR example, note that the context of the `.intersections()` function is the `LineSegment` class, which luckily has properties called `start` and `end`.
### Using IntelliJ Idea
In the past, if I needed a function, I would first write the function and only then use it. Now I do it the other way around: I first write the function call including the desired arguments. Idea will highlight it as an error and, by pressing Alt+Enter, it will suggest to create that function.
This not only works for a a typical function call like `add(person1, person2)` but also for generating operator overloading functions, like `person1 + person2` or even `person1.add(person2)`. In all these cases the IDE suggests adding something that will make the code compile.
That is how I generated the `LineSegment.intersections()` function: I typed `line.intersections(cir)` and Idea created the empty function which I then populated.
π Share your questions and comments below | π [Find other OPENRNDR & Processing posts](https://openrndr.discourse.group/search?q=%22Processing%22%20%23openrndr%3Atutorials)
---
### Author:  [@abe](https://openrndr.discourse.group/u/abe)
#### Post date: [May 7, 2020, 7:07am UTC](https://openrndr.discourse.group/t/openrndr-processing-circle-line-segment-intersection/99/2 "2020-05-07T07:07:32Z")
If you donβt like repeating the word `drawer` multiple times, you can do this:
### OPENRNDR / Kotlin
```auto
extend {
drawer.run {
clear(ColorRGBa.WHITE)
fill = ColorRGBa.fromHex("FFAA00").opacify(0.4)
stroke = ColorRGBa.BLACK.opacify(0.4)
strokeWeight = 2.0
cir = cir.movedTo(mouse.position)
lineSegment(line)
circle(cir)
circles(line.intersections(cir), 10.0)
}
}
```
---
### Author:  [@abe](https://openrndr.discourse.group/u/abe)
#### Post date: [March 9, 2021, 8:56am UTC](https://openrndr.discourse.group/t/openrndr-processing-circle-line-segment-intersection/99/3 "2021-03-09T08:56:40Z")
Ten months later I see that the program **can be greatly simplified** , in part thanks to the built-in intersection calculations. The whole program would look like this now:
> **imports**
>
> ```kotlin
> import org.openrndr.application
> import org.openrndr.color.ColorRGBa
> import org.openrndr.color.rgb
> import org.openrndr.shape.Circle
> import org.openrndr.shape.LineSegment
>
> ```
```kotlin
fun main() = application {
program {
val line = LineSegment(100.0, 100.0, 400.0, 400.0)
extend {
drawer.run {
clear(ColorRGBa.WHITE)
fill = rgb("FFAA00").opacify(0.4)
stroke = ColorRGBa.BLACK.opacify(0.4)
strokeWeight = 2.0
val cir = Circle(mouse.position, 90.0)
lineSegment(line)
circle(cir)
circles(line.contour.intersections(cir.contour).map {
it.position
}, 10.0)
}
}
}
}
```
Notice that we can query intersections between `ShapeContour` objects, therefore I convert both `line` and the `cir` to contours. That call returns a list of `ContourIntersections` containing additional information, but in this case we only care about the positions of the intersections, therefore the use of `.map {}`.
To get rid of a few extra characters I replaced `ColorRGBa.fromHex()` with `rgb()` π