Make Pick Stroke and Layer Tool In a Way More Constrasted

americogobbo · February 5, 2016, 12:50pm

My DE is:

Operating System: GNU-Linux, Ubuntu Gnome 14.04.2 - Gnome 3.10
MyPaint Version (1.3.0-alpha+git.f31a4be)

In my DE, is very difficult to see when effectively the key is working, mainly with thin strokes on scratchpad area.

achadwick · February 6, 2016, 7:27pm

mypaint has a more layer effects now, and those strokemap entries contain colour info. I wonder whether we could intensify the stroke’s colour when making the overlay shape, then apply it in an invert-y mode like Difference.

There’s not much scope for changing the shape you see blink on the screen.

Here’s what the overlay is currently made to contain. The source array is 1 bit deep with zeros or ones, the output rgba array uses MyPaint’s internal fix15 representation where numbers are stored between 0 and 2^15 inclusive. This is where colour information could be sent.

github.com

mypaint/mypaint/blob/8ee31b517edc863a1141b13419189849a2a7f76d/lib/strokemap.py#L456


      
              # Can this result always be treated as read-only?
              return array
          
          def to_string(self):
              """Convert to a string which is storable in "v2" strokemaps."""
              if self._all:
                  return self._ZDATA_ONES
              else:
                  return self._zdata
          
          def write_to_surface_tile_array(self, rgba, _c=(1<<15)/4, _a=(1<<15)/2):
              """Write to a surface's RGBA tile."""
              # neutral gray, 50% opaque
              if self._all:
                  rgba[:] = (_c, _c, _c, _a)
              else:
                  array = self.to_array()
                  rgba[:, :, 3] = array.astype('uint16') * _a
                  rgba[:, :, 0] = rgba[:, :, 3]/2
                  rgba[:, :, 1] = rgba[:, :, 3]/2
                  rgba[:, :, 2] = rgba[:, :, 3]/2

It’s called by the following code, which also makes the temporary overlay layer. This is where a mode could be set:

github.com

mypaint/mypaint/blob/8ee31b517edc863a1141b13419189849a2a7f76d/gui/document.py#L1506


      
                      # restore color
                      self.app.brushmodifier.restore_context_of_selected_brush()
          
          def context_toggle_color_cb(self, action):
              """GtkToggleAction callback for whether brushkeys restore color"""
              value = bool(action.get_active())
              self.app.preferences['misc.context_restores_color'] = value
          
          ## UI feedback for current layer/stroke
          
          def strokeblink_state_enter(self, strokeshape, bbox, center):
              """`gui.stategroup.State` entry callback for blinking a stroke"""
              overlay = lib.layer.SurfaceBackedLayer()
              overlay.load_from_strokeshape(strokeshape, bbox=bbox, center=center)
              self.tdw.overlay_layer = overlay
              bbox = tuple(overlay.get_bbox())
              self.model.canvas_area_modified(*bbox)
          
          def strokeblink_state_leave(self, reason):
              """`gui.stategroup.State` leave callback for blinking a stroke"""
              if self.tdw.overlay_layer is None:

americogobbo · February 6, 2016, 10:54pm

Perhaps this approach is better. The great difficulty, for me, is to see the thin strokes, mainly black, when they are selected/copied.
I did a simple test with a layer where different strokes (colors and widths). Copied this in two layers and I’ve applied Overlay and Difference respectively. When I hidden the original strokes (1st layer)… the contrast is nice… and to black color is also good.