Merge branch 'master' into refactor-boxplot

# Conflicts:
#	plot-config-portable/src/commonMain/kotlin/jetbrains/datalore/plot/config/GeomProtoClientSide.kt

future_changes.md

@@ -5,3 +5,5 @@
 ### Changed
 
 ### Fixed
+- ggsave: saving geomImshow() to SVG produces fuzzy picture [[LPK-188](https://github.com/JetBrains/lets-plot-kotlin/issues/188)].
+- ggsave: saving geomImshow() to raster format produces fuzzy picture. 

plot-base-portable/src/commonMain/kotlin/jetbrains/datalore/plot/base/Geom.kt

@@ -10,5 +10,7 @@ import jetbrains.datalore.plot.base.render.SvgRoot
 
 interface Geom {
  val legendKeyElementFactory: LegendKeyElementFactory
+ val wontRender: List<Aes<*>> get() = emptyList()
+ fun rangeIncludesZero(aes: Aes<*>): Boolean = false
  fun build(root: SvgRoot, aesthetics: Aesthetics, pos: PositionAdjustment, coord: CoordinateSystem, ctx: GeomContext)
 }

plot-base-portable/src/commonMain/kotlin/jetbrains/datalore/plot/base/GeomMeta.kt

@@ -24,8 +24,13 @@ object GeomMeta {
  return renderedAesByGeom[geomKind]!!
  }
 
- fun renders(geomKind: GeomKind, actualColorAes: Aes<Color>, actualFillAes: Aes<Color>): List<Aes<*>> {
- return renders(geomKind).map {
+ fun renders(
+ geomKind: GeomKind,
+ actualColorAes: Aes<Color>,
+ actualFillAes: Aes<Color>,
+ exclude: List<Aes<*>> = emptyList()
+ ): List<Aes<*>> {
+ return (renders(geomKind) - exclude).map {
  when (it) {
  Aes.COLOR -> actualColorAes
  Aes.FILL -> actualFillAes

plot-base-portable/src/commonMain/kotlin/jetbrains/datalore/plot/base/aes/AestheticsDefaults.kt

@@ -31,11 +31,6 @@ open class AestheticsDefaults {
  return this
  }
 
-
- open fun rangeIncludesZero(aes: Aes<*>): Boolean {
- return false
- }
-
  fun <T> defaultValue(aes: Aes<T>): T {
  return myDefaults[aes]
  }
@@ -82,21 +77,13 @@ open class AestheticsDefaults {
  }
 
  fun bar(): AestheticsDefaults {
- return object : AestheticsDefaults() {
- override fun rangeIncludesZero(aes: Aes<*>): Boolean {
- return aes == Aes.Y || super.rangeIncludesZero(aes)
- }
- }
+ return base()
  .update(Aes.WIDTH, 0.9)
  .update(Aes.COLOR, Color.TRANSPARENT) // no outline (transparent)
  }
 
  fun histogram(): AestheticsDefaults {
- return object : AestheticsDefaults() {
- override fun rangeIncludesZero(aes: Aes<*>): Boolean {
- return aes == Aes.Y || super.rangeIncludesZero(aes)
- }
- }
+ return base()
  .update(Aes.COLOR, Color.TRANSPARENT) // no outline (transparent)
  }
 
@@ -178,11 +165,7 @@ open class AestheticsDefaults {
  }
 
  fun area(): AestheticsDefaults {
- return object : AestheticsDefaults() {
- override fun rangeIncludesZero(aes: Aes<*>): Boolean {
- return aes == Aes.Y || super.rangeIncludesZero(aes)
- }
- }
+ return base()
  }
 
  fun density(): AestheticsDefaults {

plot-base-portable/src/commonMain/kotlin/jetbrains/datalore/plot/base/geom/AreaGeom.kt

@@ -21,6 +21,8 @@ open class AreaGeom : GeomBase() {
  var quantiles: List<Double> = DensityStat.DEF_QUANTILES
  var quantileLines: Boolean = DEF_QUANTILE_LINES
 
+ override fun rangeIncludesZero(aes: Aes<*>): Boolean = (aes == Aes.Y)
+
  protected fun dataPoints(aesthetics: Aesthetics): Iterable<DataPointAesthetics> {
  return GeomUtil.ordered_X(aesthetics.dataPoints())
  }
@@ -35,25 +37,26 @@ open class AreaGeom : GeomBase() {
  val helper = LinesHelper(pos, coord, ctx)
  val quantilesHelper = QuantilesHelper(pos, coord, ctx, quantiles)
  val dataPoints = GeomUtil.withDefined(aesthetics.dataPoints(), Aes.X, Aes.Y)
- dataPoints.sortedByDescending(DataPointAesthetics::group).groupBy(DataPointAesthetics::group).forEach { (_, groupDataPoints) ->
- quantilesHelper.splitByQuantiles(groupDataPoints, Aes.X).forEach { points ->
- val paths = helper.createBands(points, GeomUtil.TO_LOCATION_X_Y, GeomUtil.TO_LOCATION_X_ZERO)
- // If you want to retain the side edges of area: comment out the following codes,
- // and switch decorate method in LinesHelper.createBands
- appendNodes(paths, root)
-
- helper.setAlphaEnabled(false)
- appendNodes(helper.createLines(points, GeomUtil.TO_LOCATION_X_Y), root)
-
- buildHints(points, pos, coord, ctx)
- }
+ dataPoints.sortedByDescending(DataPointAesthetics::group).groupBy(DataPointAesthetics::group)
+ .forEach { (_, groupDataPoints) ->
+ quantilesHelper.splitByQuantiles(groupDataPoints, Aes.X).forEach { points ->
+ val paths = helper.createBands(points, GeomUtil.TO_LOCATION_X_Y, GeomUtil.TO_LOCATION_X_ZERO)
+ // If you want to retain the side edges of area: comment out the following codes,
+ // and switch decorate method in LinesHelper.createBands
+ appendNodes(paths, root)
+
+ helper.setAlphaEnabled(false)
+ appendNodes(helper.createLines(points, GeomUtil.TO_LOCATION_X_Y), root)
+
+ buildHints(points, pos, coord, ctx)
+ }
 
- if (quantileLines) {
- createQuantileLines(groupDataPoints, quantilesHelper).forEach { quantileLine ->
- root.add(quantileLine)
+ if (quantileLines) {
+ createQuantileLines(groupDataPoints, quantilesHelper).forEach { quantileLine ->
+ root.add(quantileLine)
+ }
  }
  }
- }
  }
 
  private fun createQuantileLines(
@@ -69,7 +72,12 @@ open class AreaGeom : GeomBase() {
  return quantilesHelper.getQuantileLineElements(dataPoints, Aes.X, toLocationBoundStart, toLocationBoundEnd)
  }
 
- private fun buildHints(dataPoints: Iterable<DataPointAesthetics>, pos: PositionAdjustment, coord: CoordinateSystem, ctx: GeomContext) {
+ private fun buildHints(
+ dataPoints: Iterable<DataPointAesthetics>,
+ pos: PositionAdjustment,
+ coord: CoordinateSystem,
+ ctx: GeomContext
+ ) {
  val geomHelper = GeomHelper(pos, coord, ctx)
  val multiPointDataList = MultiPointDataConstructor.createMultiPointDataByGroup(
  dataPoints,
@@ -108,20 +116,7 @@ open class AreaGeom : GeomBase() {
  }
 
  companion object {
-// val RENDERS = listOf(
-// Aes.X,
-// Aes.Y,
-// Aes.SIZE,
-// Aes.LINETYPE,
-// Aes.COLOR,
-// Aes.FILL,
-// Aes.ALPHA
-// )
-
  const val DEF_QUANTILE_LINES = false
-
  const val HANDLES_GROUPS = true
  }
-
-
 }

plot-base-portable/src/commonMain/kotlin/jetbrains/datalore/plot/base/geom/BarGeom.kt

@@ -18,6 +18,8 @@ import jetbrains.datalore.plot.common.data.SeriesUtil
 
 open class BarGeom : GeomBase() {
 
+ override fun rangeIncludesZero(aes: Aes<*>): Boolean = (aes == Aes.Y)
+
  override fun buildIntern(
  root: SvgRoot,
  aesthetics: Aesthetics,

plot-base-portable/src/commonMain/kotlin/jetbrains/datalore/plot/base/geom/DensityGeom.kt

@@ -20,13 +20,7 @@ class DensityGeom : AreaGeom() {
  }
 
  companion object {
-// val RENDERS: List<Aes<*>> = AreaGeom.RENDERS
- const val DEF_QUANTILE_LINES =
- AreaGeom.DEF_QUANTILE_LINES
-
- const val HANDLES_GROUPS =
- AreaGeom.HANDLES_GROUPS
+ const val DEF_QUANTILE_LINES = AreaGeom.DEF_QUANTILE_LINES
+ const val HANDLES_GROUPS = AreaGeom.HANDLES_GROUPS
  }
-
-
 }

plot-base-portable/src/commonMain/kotlin/jetbrains/datalore/plot/base/geom/ErrorBarGeom.kt

@@ -23,11 +23,20 @@ import jetbrains.datalore.plot.base.render.SvgRoot
 import jetbrains.datalore.vis.svg.SvgGElement
 import jetbrains.datalore.vis.svg.SvgLineElement
 
-class ErrorBarGeom : GeomBase() {
+class ErrorBarGeom(private val isVertical: Boolean) : GeomBase() {
 
  override val legendKeyElementFactory: LegendKeyElementFactory
  get() = ErrorBarLegendKeyElementFactory()
 
+ override val wontRender: List<Aes<*>>
+ get() {
+ return if (isVertical) {
+ listOf(Aes.Y, Aes.XMIN, Aes.XMAX, Aes.HEIGHT)
+ } else {
+ listOf(Aes.X, Aes.YMIN, Aes.YMAX, Aes.WIDTH)
+ }
+ }
+
  override fun buildIntern(
  root: SvgRoot,
  aesthetics: Aesthetics,
@@ -38,17 +47,13 @@ class ErrorBarGeom : GeomBase() {
  val geomHelper = GeomHelper(pos, coord, ctx)
  val colorsByDataPoint = HintColorUtil.createColorMarkerMapper(GeomKind.ERROR_BAR, ctx)
 
- var dataPoints = GeomUtil.withDefined(aesthetics.dataPoints(), Aes.X, Aes.YMIN, Aes.YMAX, Aes.WIDTH)
- val isVertical = dataPoints.any()
- if (!isVertical) {
- dataPoints = GeomUtil.withDefined(aesthetics.dataPoints(), Aes.Y, Aes.XMIN, Aes.XMAX, Aes.HEIGHT)
- }
-
  val xAes = if (isVertical) Aes.X else Aes.Y
  val minAes = if (isVertical) Aes.YMIN else Aes.XMIN
  val maxAes = if (isVertical) Aes.YMAX else Aes.XMAX
  val widthAes = if (isVertical) Aes.WIDTH else Aes.HEIGHT
 
+ val dataPoints = GeomUtil.withDefined(aesthetics.dataPoints(), xAes, minAes, maxAes, widthAes)
+
  for (p in dataPoints) {
  val x = p[xAes]!!
  val ymin = p[minAes]!!

plot-base-portable/src/commonMain/kotlin/jetbrains/datalore/plot/base/geom/GeomBase.kt

@@ -5,8 +5,8 @@
 
 package jetbrains.datalore.plot.base.geom
 
-import jetbrains.datalore.base.interval.DoubleSpan
 import jetbrains.datalore.base.geometry.DoubleRectangle
+import jetbrains.datalore.base.interval.DoubleSpan
 import jetbrains.datalore.plot.base.*
 import jetbrains.datalore.plot.base.geom.legend.GenericLegendKeyElementFactory
 import jetbrains.datalore.plot.base.interact.GeomTargetCollector

plot-base-portable/src/commonMain/kotlin/jetbrains/datalore/plot/base/geom/HistogramGeom.kt

@@ -7,17 +7,6 @@ package jetbrains.datalore.plot.base.geom
 
 class HistogramGeom : BarGeom() {
  companion object {
-// val RENDERS = listOf(
-// Aes.X,
-// Aes.Y,
-// Aes.COLOR,
-// Aes.FILL,
-// Aes.ALPHA,
-// //Aes.WEIGHT, // ToDo: this is actually handled by 'stat' (bin,count)
-// Aes.WIDTH,
-// Aes.SIZE
-// )
-
  const val HANDLES_GROUPS = false
  }
 }

plot-base-portable/src/commonMain/kotlin/jetbrains/datalore/plot/base/geom/LiveMapGeom.kt

@@ -12,7 +12,7 @@ import jetbrains.datalore.plot.base.render.LegendKeyElementFactory
 import jetbrains.datalore.plot.base.render.SvgRoot
 
 
-class LiveMapGeom: Geom {
+class LiveMapGeom : Geom {
  private lateinit var myMapProvider: LiveMapProvider
 
  override val legendKeyElementFactory: LegendKeyElementFactory

plot-base-portable/src/commonMain/kotlin/jetbrains/datalore/plot/base/geom/LollipopGeom.kt

@@ -11,7 +11,9 @@ import jetbrains.datalore.base.values.Color
 import jetbrains.datalore.plot.base.*
 import jetbrains.datalore.plot.base.aes.AesScaling
 import jetbrains.datalore.plot.base.geom.legend.LollipopLegendKeyElementFactory
-import jetbrains.datalore.plot.base.geom.util.*
+import jetbrains.datalore.plot.base.geom.util.GeomHelper
+import jetbrains.datalore.plot.base.geom.util.GeomUtil
+import jetbrains.datalore.plot.base.geom.util.HintColorUtil
 import jetbrains.datalore.plot.base.interact.GeomTargetCollector
 import jetbrains.datalore.plot.base.render.LegendKeyElementFactory
 import jetbrains.datalore.plot.base.render.SvgRoot
@@ -32,6 +34,14 @@ class LollipopGeom : GeomBase(), WithWidth, WithHeight {
  override val legendKeyElementFactory: LegendKeyElementFactory
  get() = LollipopLegendKeyElementFactory(fatten)
 
+ override fun rangeIncludesZero(aes: Aes<*>): Boolean {
+ // Pin the lollipops to an axis when baseline coincides with this axis and sticks are perpendicular to it
+ return aes == Aes.Y
+ && slope == 0.0
+ && intercept == 0.0
+ && direction != Direction.ALONG_AXIS
+ }
+
  override fun buildIntern(
  root: SvgRoot,
  aesthetics: Aesthetics,
@@ -121,6 +131,7 @@ class LollipopGeom : GeomBase(), WithWidth, WithHeight {
  DoubleVector((head.y - intercept) / slope, head.y)
  }
  }
+
  Direction.SLOPE -> {
  val baseX = (head.x + slope * (head.y - intercept)) / (1 + slope.pow(2))
  val baseY = slope * baseX + intercept

plot-base-portable/src/commonMain/kotlin/jetbrains/datalore/plot/base/stat/CountStat.kt

@@ -7,7 +7,6 @@ package jetbrains.datalore.plot.base.stat
 
 import jetbrains.datalore.plot.base.Aes
 import jetbrains.datalore.plot.base.DataFrame
-import jetbrains.datalore.plot.base.StatContext
 
 /**
  * Counts the number of cases at each x position
@@ -19,13 +18,6 @@ internal class CountStat : AbstractCountStat(DEF_MAPPING, count2d = false) {
  return listOf(Aes.X, Aes.WEIGHT)
  }
 
- override fun apply(data: DataFrame, statCtx: StatContext, messageConsumer: (s: String) -> Unit): DataFrame {
- if (!hasRequiredValues(data, Aes.X)) {
- return withEmptyStatValues()
- }
- return super.apply(data, statCtx, messageConsumer)
- }
-
  override fun addToStatVars(values: Set<Any>): Map<DataFrame.Variable, List<Double>> {
  val statX = values.map { it as Double }
  return mapOf(Stats.X to statX)

plot-base-portable/src/commonMain/kotlin/jetbrains/datalore/plot/base/stat/SmoothStat.kt

@@ -197,27 +197,18 @@ class SmoothStat constructor(
  Method.LM -> {
  require(polynomialDegree >= 1) { "Degree of polynomial regression must be at least 1" }
  if (polynomialDegree == 1) {
- LinearRegression(valuesX, valuesY, confidenceLevel)
+ LinearRegression.fit(valuesX, valuesY, confidenceLevel)
  } else {
- if (PolynomialRegression.canBeComputed(valuesX, valuesY, polynomialDegree)) {
- PolynomialRegression(valuesX, valuesY, confidenceLevel, polynomialDegree)
- } else {
- return result // empty stat data
- }
+ PolynomialRegression.fit(valuesX, valuesY, confidenceLevel, polynomialDegree)
  }
  }
  Method.LOESS -> {
- val evaluator = LocalPolynomialRegression(valuesX, valuesY, confidenceLevel, span)
- if (evaluator.canCompute) {
- evaluator
- } else {
- return result // empty stat data
- }
+ LocalPolynomialRegression.fit(valuesX, valuesY, confidenceLevel, span)
  }
  else -> throw IllegalArgumentException(
  "Unsupported smoother method: $smoothingMethod (only 'lm' and 'loess' methods are currently available)"
  )
- }
+ } ?: return result
 
  val rangeX = SeriesUtil.range(valuesX) ?: return result