Currently, I am working with geospatial data. I have a problem if I want to plot the contour lines. The dataset might not be sorted by the x-axis, as the lines might contain curves going back or might even be circles.

When I create a single Feature from a map containing all coordinates of the line via geom_line(map) the plot via PlotSvgExport.buildSvgImageFromRawSpecs(plotSpecRaw) is looking quite strange.

If I inspect the resulting .svg, I can see that the plotted parts are sorted by x-axis, even though they are not sorted in the lists stored in the map

<path d="M616.0933693197439 278.4722567444842 L616.0933693197439 278.4722567444842 L616.1966374794138 276.7657731094514 L616.4902197569609 275.5389922473987 L616.6647073370405 279.4956226601789 L616.803585206857 274.6645176841994 L617.3199260049732 279.96274306534906 L617.5771072454518 273.76487838532194 L618.269518277375 273.5404928259668 L618.536591103999 280.47966867647483 L619.543554576172 273.66159811618854 L621.0407450590283 274.08468023399473 L621.7343430813053 282.2642678450211 L622.5383312052581 274.5764411095006 L623.7324434878537 275.1421233958681 L623.7553919677157 283.55396054615267 L624.679661779548 275.19612272438826 L624.9914445756585 284.2475635720184 L625.9081967819366 274.77356487192446 L626.1705216472037 284.54429774635355 L627.972768647538 285.60016811219975 L628.0847414030577 273.54363841793383 L628.8990167765878 286.4028183258197 L630.2122237566509 287.67625880186097 L630.7515130346874 288.0767975106428 L630.8927648852114 272.313711963885 L631.7430456324364 288.7090614934277 L632.9130224447581 289.1698907146638 L634.262630461948 270.51862748884014 L634.6357410922647 290.05852044170024 L635.3859189875075 269.9529452024435 L635.947365418484 269.46066006162437 L636.163397660479 291.3906786341977 L636.6259282298852 268.944258715841 L637.3472226934391 268.68317458365345 L638.4986033237074 268.6538157254399 L639.1150469739223 268.7177760951745 L640.4713812696282 269.01293747351156 L641.1756622050307 269.2079641746823 L642.5007390884566 269.679278702446 L643.8495557787246 270.51286057021935 L645.2537653515465 272.0500065051019 L646.2678507657838 273.40313531065476 L646.9278173950734 283.87952931338805 L646.9851885949029 282.57463291779277 L647.0263375933282 274.9402812454791 L647.1501802522107 284.27849522623 L647.4311012994731 281.26763946091523 L647.6835345785366 280.500639289472 L647.7432797590154 276.62893985945266 L648.0633714874857 279.31317832687637 L648.1464608113747 277.9679135011975 " fill="none" stroke-width="1.0" stroke="rgb(0,0,128)" stroke-opacity="1.0">
</path>

In case I plot every single line on it's own, the file gets so huge that I can not see anything anymore.

Is there any way to force the svg export not to sort the given Features by x-axis? What can I do instead?

Hi Igor et al., nice work here! Are you planning to support consumers of this API outside a Jupyter notebook? If so, it would be nice to have some documentation on which dependencies are necessary. Based on the build.gradle file, I was able to locate the Bintray artifacts, and noticed you have written some demos, so it looks like a few use cases are already supported. Specifically, it would be nice to have a quick section in the readme for how to configure Maven/Gradle and output plots to a file or JFX window.

Also, what is the difference between this repository and JetBrains/lets-plot, and where is the appropriate place to file issues? Thanks!

I am using the kotlin lets plot api, which works 100% on jupyter and in standalone apps,

however I'm trying to use it on an android app and at the moment to build I get a bunch of errors that say like this

Duplicate class kotlin.ArrayIntrinsicsKt found in modules jetified-kotlin-stdlib-1.3.72.jar (org.jetbrains.kotlin:kotlin-stdlib:1.3.72) and jetified-lets-plot-common-1.3.1.jar (org.jetbrains.lets-plot:lets-plot-common:1.3.1)

and

Duplicate class org.jetbrains.annotations.TestOnly found in modules jetified-annotations-13.0.jar (org.jetbrains:annotations:13.0) and jetified-lets-plot-common-1.3.1.jar (org.jetbrains.lets-plot:lets-plot-common:1.3.1)

I understand that I have to choose only one of the libraries to be compiled, but if I remove lets-plot from the gradle the project renders unusable at 'grafica.kt'

My question is:

Can I remove 'org.jetbrains.kotlin:kotlin-stdlib:1.3.72' and 'org.jetbrains:annotations:13.0' safely? and If so, how can I do this?

Thanks in advance!

Project description: User inputs two numbers and the app displays a plot of them

I've opened the same issue at :

https://youtrack.jetbrains.com/issue/KT-39737

where I've attached a sample project

Plot_app.zip

Is there any example notebook to show how to plot timeseries data with time in X-axis?

X-axis data could be any of the Datetime classes like LocalDate, LocalDateTime or ZonedDateTime etc

After updating to 3.0.0, I encountered the following error:

Cannot access class 'jetbrains.datalore.vis.svgToString.SvgToString'. Check your module classpath for missing or conflicting dependencies

After reading the dev docs, I added this dependency:

implementation("org.jetbrains.lets-plot:lets-plot-jfx:2.0.3")

This did not work due the following error:

Could not find org.jetbrains.kotlinx:kotlinx-html-jvm:0.7.2.

Then I added this dependency:

implementation("org.jetbrains.kotlinx:kotlinx-html-jvm:0.7.3")

And everything worked again.

I'm trying to visualize a number of commits made per module in my single-repo project, per month. On X axis I want to have labels like 2020-04, and Y axis should show the number of commits. My code is as follows:

    ...
    val plotData = mapOf (
        "yearMonth" to yearMonths,
        "module" to modules,
    )

    var plot = lets_plot(plotData) +
            geom_bar { x = "yearMonth"; fill = "module" } +
            ggsize(1920, 1080) +
            ggtitle("Number of commits per module")

Everything works fine, except that I'm getting such order of labels which looks totally random:

As you can see, the order is not even alphanumeric, and I'd expect it to be so (analogy to ggplot, see e.g. https://sebastiansauer.github.io/ordering-bars/: "And the rule is: ... if character, an alphabetical order ist used"). My data provided in yearMonths is ordered the way I want (alphanumerically).

How can I control the order of the labels? I'm also curious what's the contract with lets-plot for this matter. How about sorting it alphanumerically by default, and providing a way to customize it?

I didn't manage to reproduce it on a smaller set of data.

When I go to https://github.com/JetBrains/lets-plot-kotlin/blob/master/docs/guide/user_guide.ipynb and click on the geom_reference link to get to the documentation, I get a 404. I don't exactly know why, the link seems to be correct (when I hover over it). When I copy the url manually and visit https://render.githubusercontent.com/plot-api/docs/plot-api/jetbrains.lets-plot.geom/index.html then I get an 'Unknown type'.

For now I just render with htmlpreview: https://htmlpreview.github.io/?https://github.com/JetBrains/lets-plot-kotlin/blob/master/plot-api/docs/plot-api/index.html, but a proper solution would be convenient.

Hi, I've created a plot using following code:

val data = mapOf(
    "Task interval coefficient of variation" to listOf(1.17546, 1.19216, 1.20941, 1.22708, 1.24521, 1.26378, 1.28274, 1.30207, 1.32178, 1.34187, 1.3623, 1.383, 1.40404, 1.42535, 1.44695, 1.46884, 1.49097, 1.51339, 1.53597, 1.55886),
    "Average processing time" to listOf(41.1325, 41.1325, 41.1325, 41.1325, 41.1325, 41.1325, 41.1325, 41.1325, 41.1325, 41.1325, 41.1325, 41.1325, 41.1325, 41.1325, 41.1325, 41.1325, 41.1325, 41.1325, 41.1325, 41.1325)
)

val plot = ggplot(data) { x = "Task interval coefficient of variation"; y = "Average processing time" } + geomPoint() + geomSmooth()

Unfortunately, when trying to save it to PNG file using following code:

ggsave(plot, "p1.png")

I've got following error:

Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
	at java.base/java.lang.Double.valueOf(Double.java:537)
	at jetbrains.datalore.plot.base.scale.breaks.LinearBreaksHelper$Companion.computeNiceBreaks(LinearBreaksHelper.kt:82)
	at jetbrains.datalore.plot.base.scale.breaks.LinearBreaksHelper$Companion.access$computeNiceBreaks(LinearBreaksHelper.kt:42)
	at jetbrains.datalore.plot.base.scale.breaks.LinearBreaksHelper.<init>(LinearBreaksHelper.kt:30)
	at jetbrains.datalore.plot.base.scale.breaks.LinearBreaksHelper.<init>(LinearBreaksHelper.kt:10)
	at jetbrains.datalore.plot.base.scale.transform.LinearBreaksGen$Companion.generateBreakValues$plot_base_portable(LinearBreaksGen.kt:37)
	at jetbrains.datalore.plot.base.scale.transform.LinearBreaksGen.generateBreaks(LinearBreaksGen.kt:21)
	at jetbrains.datalore.plot.base.scale.transform.Transforms$BreaksGeneratorForTransformedDomain.generateBreaks(Transforms.kt:70)
	at jetbrains.datalore.plot.builder.layout.axis.AdaptableAxisBreaksProvider.getBreaks(AdaptableAxisBreaksProvider.kt:25)
	at jetbrains.datalore.plot.builder.layout.axis.label.BreakLabelsLayoutUtil.getFlexBreaks(BreakLabelsLayoutUtil.kt:24)
	at jetbrains.datalore.plot.builder.layout.axis.label.VerticalFlexBreaksLabelsLayout.getBreaks(VerticalFlexBreaksLabelsLayout.kt:53)
	at jetbrains.datalore.plot.builder.layout.axis.label.VerticalFlexBreaksLabelsLayout.doLayout(VerticalFlexBreaksLabelsLayout.kt:42)
	at jetbrains.datalore.plot.builder.layout.axis.AxisLayouter.doLayout(AxisLayouter.kt:22)
	at jetbrains.datalore.plot.builder.layout.PlotAxisLayout.doLayout(PlotAxisLayout.kt:42)
	at jetbrains.datalore.plot.builder.layout.XYPlotTileLayout$Companion.computeVAxisInfo(XYPlotTileLayout.kt:203)
	at jetbrains.datalore.plot.builder.layout.XYPlotTileLayout$Companion.computeAxisInfos(XYPlotTileLayout.kt:134)
	at jetbrains.datalore.plot.builder.layout.XYPlotTileLayout$Companion.access$computeAxisInfos(XYPlotTileLayout.kt:103)
	at jetbrains.datalore.plot.builder.layout.XYPlotTileLayout.doLayout(XYPlotTileLayout.kt:27)
	at jetbrains.datalore.plot.builder.layout.SingleTilePlotLayout.doLayout(SingleTilePlotLayout.kt:27)
	at jetbrains.datalore.plot.builder.PlotSvgComponent.buildPlotComponents(PlotSvgComponent.kt:182)
	at jetbrains.datalore.plot.builder.PlotSvgComponent.buildPlot(PlotSvgComponent.kt:111)
	at jetbrains.datalore.plot.builder.PlotSvgComponent.buildComponent(PlotSvgComponent.kt:86)
	at jetbrains.datalore.plot.base.render.svg.SvgComponent.buildComponentIntern(SvgComponent.kt:46)
	at jetbrains.datalore.plot.base.render.svg.SvgComponent.ensureBuilt(SvgComponent.kt:39)
	at jetbrains.datalore.plot.base.render.svg.SvgComponent.getRootGroup(SvgComponent.kt:33)
	at jetbrains.datalore.plot.builder.PlotContainerPortable.buildContent(PlotContainerPortable.kt:87)
	at jetbrains.datalore.plot.builder.PlotContainerPortable.ensureContentBuilt(PlotContainerPortable.kt:44)
	at jetbrains.datalore.plot.MonolithicCommon.buildSvgImagesFromRawSpecs(MonolithicCommon.kt:51)
	at jetbrains.datalore.plot.PlotSvgExportPortable.buildSvgImageFromRawSpecs(PlotSvgExportPortable.kt:42)
	at jetbrains.datalore.plot.PlotSvgExport.buildSvgImageFromRawSpecs(PlotSvgExport.kt:25)
	at jetbrains.datalore.plot.PlotSvgExport.buildSvgImageFromRawSpecs$default(PlotSvgExport.kt:21)
	at jetbrains.datalore.plot.PlotImageExport.buildImageFromRawSpecs(PlotImageExport.kt:90)

Process finished with exit code 1

The direct reason of error is probably the fact that in LinearBreaksHelper$Companion.computeNiceBreaks function step has such a small value that ticks value is never getting higher, so the program never exits the while loop.

When trying to render a simple plot in a kotlin application

var p: Plot = lets_plot(data)
        p += geom_density(color = "dark_green", alpha = .3) { x = "rating"; fill = "cond" }
        p + ggsize(500, 250)
        p.show()

it just dies

Exception in thread "main" java.lang.IllegalStateException: Frontend context is not defined
	at jetbrains.letsPlot.LetsPlot$frontendContext$1.display(LetsPlot.kt:16)
	at jetbrains.letsPlot.intern.Plot.show(Core.kt:49)
	at org.kalasim.test.LetsPlotASimulation.main(DemoTests.kt:42)

It would be cool if (depending on the chosen backend (jfx, batik) a corresponding window could that simply shows the plot.

Currently the user has to dig through the code-base in particular https://github.com/JetBrains/lets-plot-kotlin/blob/master/demo/jvm-batik/src/main/kotlin/minimalDemo/Main.kt to to finally implement a utility to achieve this core functionality

fun Plot.showPlot() {

// Setup

    val BATIK_MESSAGE_CALLBACK = object : BatikMessageCallback {
        override fun handleMessage(message: String) {
            println(message)
        }

        override fun handleException(e: Exception) {
            if(e is RuntimeException) {
                throw e
            }
            throw RuntimeException(e)
        }
    }

    val SVG_COMPONENT_FACTORY_BATIK =
        { svg: SvgSvgElement -> BatikMapperComponent(svg, BATIK_MESSAGE_CALLBACK) }

    val AWT_EDT_EXECUTOR = { runnable: () -> Unit ->
        // Just invoke in the current thread.
        runnable.invoke()
    }

    SwingUtilities.invokeLater {

        // Create Swing Panel showing the plot.
        val plotSpec = toSpec()
        val plotSize = DoubleVector(600.0, 300.0)

        val component =
            MonolithicAwt.buildPlotFromRawSpecs(
                plotSpec,
                plotSize,
//                    plotMaxWidth = null,
                SVG_COMPONENT_FACTORY_BATIK, AWT_EDT_EXECUTOR
            ) {
                for(message in it) {
                    println("PLOT MESSAGE: $message")
                }
            }

        // Show plot in Swing frame.
        val frame = JFrame("The Minimal")
        frame.contentPane.add(component)
        frame.defaultCloseOperation = WindowConstants.EXIT_ON_CLOSE
        frame.pack()
        frame.isVisible = true
    }
}

Note: Clearly this extension lacks beauty as it is does not adjust the plot width when the user resizes the window. A better approach (similar how PyCharm does it in the ide) would be a small tabbed windows where all plots the users shows with .show() are grouped together. In kravis I've implemented a similar output viewer (although not really pretty as of now):

I'm not sure where the best place to ask this is, but has there been work towards adding lets-plot capabilities to Intellij IDEA's Kotlin scratch files? I use scratch files on the daily and being able to quickly plot something without having to set up a new project environment or switch contexts would be huge. Thanks for your great work!

Is it possible to use geomImag like in this examples? https://nbviewer.org/github/JetBrains/lets-plot-docs/blob/master/source/examples/cookbook/image_101.ipynb

Please release native support of plotting data in realtime. Unfortunately, a trick which is discussed here is just a workaround with significant efforts .

As @alshan mentioned "Lets-Plot itself doesn't support incremental updates at the moment" but I suppose some kind of a good workaround could be included to the ets-plot-kotlin lib.

Is it possible to make a group by several columns (without mappings to other aesthetics)? For example like this: group = listOf("col1", "col2")

Because of operator precedence, the used class approach for geoms (such as geomBar) fails to provide a convenient syntax when showing a plot. It's a confusing mix of ., +, as well as round and curly brackets:

Example

// letsplot
(df.letsPlot{ x = "status" } + geomBar ()).show()
            
// kravis for comparison
df.plot(x="status").geomBar().show()

By using a builder approach and using . for chaining (as we do in most other kotlin apis including kotlin-dataframe, a more user-friendly API experience would be possible.

I'm new to data analysis and I started out with lets-plot for data visualization!

Basically I'm trying to find a way to add images in geomBar(), it could be an image on the bottom bar or even extended through all the bar or something like that. The main purpose is to make it more beautiful and easier to catch the report at first instead of reading a text.

But I can't find that feature available there, I've tried with geomImage() but I'm not sure if that's the feature to use, would appreciate any guidance or know if there are plans in the future for adding it