- Jump To … +
  ./demo/canvas-001.js ./demo/canvas-002.js ./demo/canvas-003.js ./demo/canvas-004.js ./demo/canvas-005.js ./demo/canvas-006.js ./demo/canvas-007.js ./demo/canvas-008.js ./demo/canvas-009.js ./demo/canvas-010.js ./demo/canvas-011.js ./demo/canvas-012.js ./demo/canvas-013.js ./demo/canvas-014.js ./demo/canvas-015.js ./demo/canvas-015a.js ./demo/canvas-016.js ./demo/canvas-017.js ./demo/canvas-018.js ./demo/canvas-019.js ./demo/canvas-019a.js ./demo/canvas-020.js ./demo/canvas-021.js ./demo/canvas-022.js ./demo/canvas-023.js ./demo/canvas-024.js ./demo/canvas-025.js ./demo/canvas-026.js ./demo/canvas-027.js ./demo/canvas-028.js ./demo/canvas-029.js ./demo/canvas-030.js ./demo/canvas-031.js ./demo/canvas-032.js ./demo/canvas-033.js ./demo/canvas-034.js ./demo/canvas-035.js ./demo/canvas-036.js ./demo/canvas-037.js ./demo/canvas-038.js ./demo/canvas-039.js ./demo/canvas-040.js ./demo/canvas-041.js ./demo/canvas-042.js ./demo/canvas-043.js ./demo/canvas-044.js ./demo/canvas-045.js ./demo/canvas-046.js ./demo/canvas-047.js ./demo/canvas-048.js ./demo/canvas-049.js ./demo/canvas-050.js ./demo/canvas-051.js ./demo/canvas-052.js ./demo/canvas-053.js ./demo/canvas-054.js ./demo/canvas-055.js ./demo/canvas-056.js ./demo/canvas-058.js ./demo/canvas-059.js ./demo/canvas-060.js ./demo/canvas-061.js ./demo/canvas-062.js ./demo/canvas-063.js ./demo/canvas-064.js ./demo/core-001.js ./demo/delaunator-001.js ./demo/delaunator-002.js ./demo/dom-001.js ./demo/dom-002.js ./demo/dom-003.js ./demo/dom-004.js ./demo/dom-005.js ./demo/dom-006.js ./demo/dom-007.js ./demo/dom-008.js ./demo/dom-009.js ./demo/dom-010.js ./demo/dom-011.js ./demo/dom-012.js ./demo/dom-013.js ./demo/dom-015.js ./demo/dom-016.js ./demo/dom-017.js ./demo/dom-018.js ./demo/filters-001.js ./demo/filters-002.js ./demo/filters-002a.js ./demo/filters-003.js ./demo/filters-004.js ./demo/filters-005.js ./demo/filters-006.js ./demo/filters-007.js ./demo/filters-008.js ./demo/filters-009.js ./demo/filters-010.js ./demo/filters-011.js ./demo/filters-012.js ./demo/filters-013.js ./demo/filters-014.js ./demo/filters-015.js ./demo/filters-016.js ./demo/filters-017.js ./demo/filters-018.js ./demo/filters-019.js ./demo/filters-020.js ./demo/filters-021.js ./demo/filters-022.js ./demo/filters-023.js ./demo/filters-024.js ./demo/filters-025.js ./demo/filters-026.js ./demo/filters-027.js ./demo/filters-028.js ./demo/filters-101.js ./demo/filters-102.js ./demo/filters-103.js ./demo/filters-104.js ./demo/filters-105.js ./demo/filters-501.js ./demo/filters-502.js ./demo/filters-503.js ./demo/filters-504.js ./demo/filters-505.js ./demo/mediapipe-001.js ./demo/mediapipe-002.js ./demo/mediapipe-003.js ./demo/modules-001.js ./demo/modules-002.js ./demo/modules-003.js ./demo/modules-004.js ./demo/modules-005.js ./demo/modules-006.js ./demo/packets-001.js ./demo/packets-002.js ./demo/particles-001.js ./demo/particles-002.js ./demo/particles-003.js ./demo/particles-004.js ./demo/particles-005.js ./demo/particles-006.js ./demo/particles-007.js ./demo/particles-008.js ./demo/particles-009.js ./demo/particles-010.js ./demo/particles-011.js ./demo/particles-012.js ./demo/particles-013.js ./demo/particles-014.js ./demo/particles-015.js ./demo/particles-016.js ./demo/rapier-001.js ./demo/snippets-001.js ./demo/snippets-002.js ./demo/snippets-003.js ./demo/snippets-004.js ./demo/snippets-005.js ./demo/snippets-006.js ./demo/tensorflow-001.js ./demo/tensorflow-002.js ./demo/utilities.js

- §

  # Demo Filters 024

  Filter parameters: curveWeights

- §

  Run code

      import * as scrawl from '../source/scrawl.js';

      import { addImageDragAndDrop } from './utilities.js';

- §

  #### Scene setup

      scrawl.importDomImage('.flowers');

      const oCanvas = scrawl.library.canvas['output-canvas'];
      const wCanvas = scrawl.library.canvas['channel-weights-canvas'];

- §

  #### Curves filter

      const weights = new Array(1024);
      weights.fill(0);

      const myFilter = scrawl.makeFilter({

          name: 'my-filter',
          method: 'curveWeights',

          weights: [...weights],
      });

- §

  #### Output canvas

      const piccy = scrawl.makePicture({

          name: 'base-piccy',
          group: oCanvas.base.name,

          asset: 'iris',

          width: '100%',
          height: '100%',

          copyWidth: '100%',
          copyHeight: '100%',

          method: 'fill',

          filters: ['my-filter'],
      });

- §

  #### Weights canvas

      wCanvas.buildCell({

          name: 'curves-cell',
          dimensions: [360, 360],
      });

      const curveArray = ['red', 'green', 'blue', 'black'];

      curveArray.forEach((name, index) => {

          scrawl.makeGroup({

              name: `${name}-pins-group`,
              host: wCanvas.base.name,
              order: index,
          });

          scrawl.makeWheel({

              name: `${name}-pin-start`,
              group: `${name}-pins-group`,
              radius: 12,
              start: [0, 360],
              fillStyle: name,
              strokeStyle: 'gold',
              method: 'fillThenDraw',
              handle: ['center', 'center'],

          }).clone({

              name: `${name}-pin-cs`,
              radius: 8,
              start: [120, 240],
              method: 'fill',

          }).clone({

              name: `${name}-pin-ce`,
              start: [240, 120],

          }).clone({

              name: `${name}-pin-end`,
              radius: 12,
              start: [360, 0],
              method: 'fillThenDraw',
          });

          scrawl.makeBezier({

              name: `${name}-bezier`,
              group: 'curves-cell',

              strokeStyle: name,
              lineWidth: 1,
              method: 'draw',

              pivot: `${name}-pin-start`,
              lockTo: 'pivot',
              startControlPivot: `${name}-pin-cs`,
              startControlLockTo: 'pivot',
              endControlPivot: `${name}-pin-ce`,
              endControlLockTo: 'pivot',
              endPivot: `${name}-pin-end`,
              endLockTo: 'pivot',

              useStartAsControlPoint: true,
              useAsPath: true,
          });
      });

- §

  #### User interaction

  Create the drag-and-drop zone

      let draggedPin;

      const dragGroup = scrawl.makeGroup({
          name: 'drag-group',
      });

      dragGroup.addArtefacts('black-pin-start', 'black-pin-cs', 'black-pin-ce', 'black-pin-end');

      const currentPin = scrawl.makeDragZone({

          zone: wCanvas,
          collisionGroup: 'drag-group',
          endOn: ['up', 'leave'],
          exposeCurrentArtefact: true,
          preventTouchDefaultWhenDragging: true,

          updateOnStart: () => {

              draggedPin = currentPin();

              if (typeof draggedPin != 'boolean' && draggedPin) {

                  const pin = draggedPin.artefact,
                      name = pin.name;

                  if (name.indexOf('start') > 0 || name.indexOf('end') > 0) {

- §

  @ts-expect-error

                      pin.isBeingDragged = false;
                      pin.set({
                          lockXTo: 'mouse',
                      });
                  }
              }
          },

          updateOnEnd: () => {

              if (typeof draggedPin != 'boolean' && draggedPin) {

                  const pin = draggedPin.artefact,
                      name = pin.name;

                  if (name.indexOf('start') > 0 || name.indexOf('end') > 0) {

                      pin.set({
                          start: pin.get('position'),
                          lockXTo: 'start',
                      });
                  }
              }
              draggedPin = false;

              recalculateWeights();
          },
      });

- §

  Filter weights recalculation

      const recalculateWeights = function () {

          const allCurve = scrawl.library.entity['black-bezier'],
              redCurve = scrawl.library.entity['red-bezier'],
              greenCurve = scrawl.library.entity['green-bezier'],
              blueCurve = scrawl.library.entity['blue-bezier'];

          const inverseStep = 256 / 360;

          return function () {

              const [startAllX] = allCurve.get('position');
              const [endAllX] = allCurve.get('endPosition');

              const [startRedX] = redCurve.get('position');
              const [endRedX] = redCurve.get('endPosition');

              const [startGreenX] = greenCurve.get('position');
              const [endGreenX] = greenCurve.get('endPosition');

              const [startBlueX] = blueCurve.get('position');
              const [endBlueX] = blueCurve.get('endPosition');

              const redArray = [],
                  greenArray = [],
                  blueArray = [],
                  allArray = [];

              for (let i = 0; i < 1; i += 0.001) {

                  const r = redCurve.getPathPositionData(i),
                      g = greenCurve.getPathPositionData(i),
                      b = blueCurve.getPathPositionData(i),
                      a = allCurve.getPathPositionData(i);

                  let {x:xr, y:yr} = r;
                  let {x:xg, y:yg} = g;
                  let {x:xb, y:yb} = b;
                  let {x:xa, y:ya} = a;

                  xr = Math.floor(xr * inverseStep);
                  xg = Math.floor(xg * inverseStep);
                  xb = Math.floor(xb * inverseStep);
                  xa = Math.floor(xa * inverseStep);

                  yr = 256 - (yr * inverseStep);
                  yg = 256 - (yg * inverseStep);
                  yb = 256 - (yb * inverseStep);
                  ya = 256 - (ya * inverseStep);

                  if (!redArray[xr]) redArray[xr] = [];
                  redArray[xr].push(yr);

                  if (!greenArray[xg]) greenArray[xg] = [];
                  greenArray[xg].push(yg);

                  if (!blueArray[xb]) blueArray[xb] = [];
                  blueArray[xb].push(yb);

                  if (!allArray[xa]) allArray[xa] = [];
                  allArray[xa].push(ya);
              }

              let temp, tempLen, res;

              for (let i = 0, cursor = 0; i < 256; i++) {

                  if (!redArray[i]) redArray[i] = [];
                  tempLen = redArray[i].length;
                  if (!tempLen) {
                      if (startRedX < endRedX) {
                          if (i < startRedX) weights[cursor] = -i;
                          else weights[cursor] = 255 - i;
                      }
                      else {
                          if (i > startRedX) weights[cursor] = -i;
                          else weights[cursor] = 255 - i;
                      }
                  }
                  else {
                      temp = [...redArray[i]];
                      res = Math.round(temp.reduce((acc, val) => acc + val, 0) / tempLen);
                      weights[cursor] = res - i;
                  }
                  cursor++;

                  if (!greenArray[i]) greenArray[i] = [];
                  tempLen = greenArray[i].length;
                  if (!tempLen) {
                      if (startGreenX < endGreenX) {
                          if (i < startGreenX) weights[cursor] = -i;
                          else weights[cursor] = 255 - i;
                      }
                      else {
                          if (i > startGreenX) weights[cursor] = -i;
                          else weights[cursor] = 255 - i;
                      }
                  }
                  else {
                      temp = [...greenArray[i]];
                      res = Math.round(temp.reduce((acc, val) => acc + val, 0) / tempLen);
                      weights[cursor] = res - i;
                  }
                  cursor++;

                  if (!blueArray[i]) blueArray[i] = [];
                  tempLen = blueArray[i].length;
                  if (!tempLen) {
                      if (startBlueX < endBlueX) {
                          if (i < startBlueX) weights[cursor] = -i;
                          else weights[cursor] = 255 - i;
                      }
                      else {
                          if (i > startBlueX) weights[cursor] = -i;
                          else weights[cursor] = 255 - i;
                      }
                  }
                  else {
                      temp = [...blueArray[i]];
                      res = Math.round(temp.reduce((acc, val) => acc + val, 0) / tempLen);
                      weights[cursor] = res - i;
                  }
                  cursor++;

                  if (!allArray[i]) allArray[i] = [];
                  tempLen = allArray[i].length;
                  if (!tempLen) {
                      if (startAllX < endAllX) {
                          if (i < startAllX) weights[cursor] = -i;
                          else weights[cursor] = 255 - i;
                      }
                      else {
                          if (i > startAllX) weights[cursor] = -i;
                          else weights[cursor] = 255 - i;
                      }
                  }
                  else {
                      temp = [...allArray[i]];
                      res = Math.round(temp.reduce((acc, val) => acc + val, 0) / tempLen);
                      weights[cursor] = res - i;
                  }
                  cursor++;
              }

              myFilter.set({
                  weights: [...weights],
              });

              updateOutput();
          }
      }();

- §

  #### Scene animation

      scrawl.makeRender({

          name: "demo-animation",
          target: [wCanvas, oCanvas],
      });

      const updateOutput = () => {

          document.querySelector('#reportmessage').textContent = weights.join(', ');
      }

      updateOutput();

- §

  #### User interaction

  Top form (for opacity, use mixed channel controls)

      scrawl.makeUpdater({

          event: ['input', 'change'],
          origin: '.controlItem',

          target: myFilter,

          useNativeListener: true,
          preventDefault: true,

          updates: {

              opacity: ['opacity', 'float'],
              useMixedChannel: ['useMixedChannel', 'boolean'],
          },
      });

- §

  Channel buttons (under the curves canvas)

      let selected, selectedGroup;

      scrawl.addNativeListener('click', (e) => {

          if (e && e.target && e.target.id) {

              if (selectedGroup) {

                  const order = selectedGroup.get('order') - 10;

                  selectedGroup.setArtefacts({ order });
                  selectedGroup.set({ order });
              }

              selected = e.target.id;
              selectedGroup = scrawl.library.group[`${selected}-pins-group`];

              if (selectedGroup) {

                  document.querySelectorAll('.channel-selector').forEach(el => el.classList.remove('selected'));

                  const order = selectedGroup.get('order') + 10;

                  selectedGroup.setArtefacts({ order });
                  selectedGroup.set({ order });

                  dragGroup.clearArtefacts();
                  dragGroup.addArtefacts(`${selected}-pin-start`, `${selected}-pin-cs`, `${selected}-pin-ce`, `${selected}-pin-end`);

                  e.target.classList.add('selected');
              }
          }
      }, '.channel-selector');

      scrawl.addNativeListener(['input', 'change'], () => updateOutput(), '.controlItem');

- §

  Setup form @ts-expect-error

      document.querySelector('#useMixedChannel').options.selectedIndex = 1;

- §

  @ts-expect-error

      document.querySelector('#opacity').value = 1;

- §

  #### Drag-and-Drop image loading functionality

      addImageDragAndDrop(oCanvas, '#my-image-store', piccy);

- §

  #### Development and testing

      console.log(scrawl.library);