comparison src/app/waveform/waveform.component.ts @ 118:5a4cd7add25a

Update colour mappers to slightly changed API; add green & sunset

   }
 
   interpolatingMapper(hexColours) {
     const colours = hexColours.map(n => {
       const i = parseInt(n, 16);
-      return [ (i >> 16) & 255, (i >> 8) & 255, i & 255, 255 ];
+      return [ ((i >> 16) & 255) / 255.0,
+               ((i >> 8) & 255) / 255.0,
+               ((i) & 255) / 255.0 ];
     });
     const last = colours.length - 1;
     return (value => {
-      // value must be in the range [0,1]. We quantize to 256 levels,
-      // as the PNG encoder deep inside uses a limited palette for
-      // simplicity. Should document this for the mapper. Also that
-      // individual colour values should be integers
-      value = Math.round(value * 255) / 255;
       const m = value * last;
       if (m >= last) {
         return colours[last];
       }
       if (m <= 0) {

       const base = Math.floor(m);
       const prop0 = base + 1.0 - m;
       const prop1 = m - base;
       const c0 = colours[base];
       const c1 = colours[base+1];
-      return [ Math.round(c0[0] * prop0 + c1[0] * prop1),
-               Math.round(c0[1] * prop0 + c1[1] * prop1),
-               Math.round(c0[2] * prop0 + c1[2] * prop1),
-               255 ];
+      return [ c0[0] * prop0 + c1[0] * prop1,
+               c0[1] * prop0 + c1[1] * prop1,
+               c0[2] * prop0 + c1[2] * prop1 ];
     });
   }
 
   iceMapper() {
     let hexColours = [

       "ffffff", "ffff00", "f7fcf0", "e0f3db", "ccebc5", "a8ddb5",
       "7bccc4", "4eb3d3", "2b8cbe", "0868ac", "084081", "042040"
     ];
     hexColours.reverse();
     return this.interpolatingMapper(hexColours);
+  }
+
+  hsv2rgb(h, s, v) { // all values in range [0, 1]
+    const i = Math.floor(h * 6);
+    const f = h * 6 - i;
+    const p = v * (1 - s);
+    const q = v * (1 - f * s);
+    const t = v * (1 - (1 - f) * s);
+    let r = 0, g = 0, b = 0;
+    switch (i % 6) {
+        case 0: r = v, g = t, b = p; break;
+        case 1: r = q, g = v, b = p; break;
+        case 2: r = p, g = v, b = t; break;
+        case 3: r = p, g = q, b = v; break;
+        case 4: r = t, g = p, b = v; break;
+        case 5: r = v, g = p, b = q; break;
+    }
+    return [ r, g, b ];
+  }
+  
+  greenMapper() {
+    const blue = 0.6666;
+    const pieslice = 0.3333;
+    return (value => {
+      const h = blue - value * 2.0 * pieslice;
+      const s = 0.5 + value / 2.0;
+      const v = value;
+      return this.hsv2rgb(h, s, v);
+    });
+  }
+
+  sunsetMapper() {
+    return (value => {
+      let r = (value - 0.24) * 2.38;
+      let g = (value - 0.64) * 2.777;
+      let b = (3.6 * value);
+      if (value > 0.277) b = 2.0 - b;
+      return [ r, g, b ];
+    });
   }
 
   renderWaveform(buffer: AudioBuffer): void {
     const height: number = this.trackDiv.nativeElement.getBoundingClientRect().height / 2;
     const waveTrack = this.timeline.getTrackById('wave');

   renderSpectrogram(buffer: AudioBuffer): void {
     const height: number = this.trackDiv.nativeElement.getBoundingClientRect().height / 2;
     const gridTrack = this.timeline.getTrackById('grid');
 
     const spectrogramLayer = new wavesUI.helpers.SpectrogramLayer(buffer, {
-      top: 10,
+      top: height * 0.05,
       height: height * 0.9,
       stepSize: 512,
-      fftSize: 1024
+      fftSize: 1024,
+      normalise: 'none',
+      mapper: this.sunsetMapper()
     });
     this.addLayer(spectrogramLayer, gridTrack, this.timeline.timeContext);
 
     this.timeline.tracks.update();
   }

   private renderFeatures(extracted: SimpleResponse, colour: Colour): void {
     if (!extracted.hasOwnProperty('features') || !extracted.hasOwnProperty('outputDescriptor')) return;
     if (!extracted.features.hasOwnProperty('shape') || !extracted.features.hasOwnProperty('data')) return;
     const features: FeatureCollection = (extracted.features as FeatureCollection);
     const outputDescriptor = extracted.outputDescriptor;
-    const height = this.trackDiv.nativeElement.getBoundingClientRect().height;
-    const waveTrack = this.timeline.getTrackById('main');
+    const height = this.trackDiv.nativeElement.getBoundingClientRect().height / 2;
+    const waveTrack = this.timeline.getTrackById('wave');
 
     // TODO refactor all of this
     switch (features.shape) {
       case 'vector': {
         const stepDuration = (features as FixedSpacedFeatures).stepDuration;

         const gain = (targetValue > 0.0 ? (1.0 / targetValue) : 1.0);
         console.log("setting gain to " + gain);
         const matrixEntity = new wavesUI.utils.PrefilledMatrixEntity(matrixData);
         let matrixLayer = new wavesUI.helpers.MatrixLayer(matrixEntity, {
           gain,
-          height: height * 0.8,
-          top: height * 0.1,
+          height: height * 0.9,
+          top: height * 0.05,
           normalise: 'none',
           mapper: this.iceMapper()
         });
         this.colouredLayers.set(this.addLayer(
           matrixLayer,