comparison src/app/waveform/waveform.component.ts @ 301:fff3a4fba992

Change guard at top of renderFeatures for change in response shape + a bunch of formatting changes.

 import {Subscription} from 'rxjs/Subscription';
 import {
   FeatureCollection,
   SimpleResponse,
   VectorFeatures,
-  MatrixFeatures,
-  TrackFeature,
-  TrackFeatures
+  MatrixFeatures
 } from 'piper/HigherLevelUtilities';
 import {toSeconds} from 'piper';
 import {FeatureList, Feature} from 'piper/Feature';
 import * as Hammer from 'hammerjs';
 import {WavesSpectrogramLayer} from '../spectrogram/Spectrogram';

       element.addEventListener('touchend', () => {
         if (isZooming) {
           isZooming = false;
           zoomGestureJustEnded = true;
         }
-       });
+      });
       element.addEventListener('touchmove', zoom);
     }
     // this.timeline.createTrack(track, height/2, `wave-${this.trackIdPrefix}`);
     // this.timeline.createTrack(track, height/2, `grid-${this.trackIdPrefix}`);
   }

         }
       }
     }
     if (sample.length === 0) {
       console.log('WARNING: No samples gathered, even though we hoped for ' +
-                  (m_per * w) + ' of them');
+        (m_per * w) + ' of them');
       return 0.0;
     }
     sample.sort((a, b) => { return a - b; });
     const ix = Math.floor((sample.length * percentile) / 100);
     console.log('Estimating ' + percentile + '-%ile of ' +
-                n + '-sample dataset (' + w + ' x ' + h + ') as value ' + ix +
-                ' of sorted ' + sample.length + '-sample subset');
+      n + '-sample dataset (' + w + ' x ' + h + ') as value ' + ix +
+      ' of sorted ' + sample.length + '-sample subset');
     const estimate = sample[ix];
     console.log('Estimate is: ' + estimate + ' (where min sampled value = ' +
-                sample[0] + ' and max = ' + sample[sample.length - 1] + ')');
+      sample[0] + ' and max = ' + sample[sample.length - 1] + ')');
     return estimate;
   }
 
   interpolatingMapper(hexColours) {
     const colours = hexColours.map(n => {
       const i = parseInt(n, 16);
       return [ ((i >> 16) & 255) / 255.0,
-               ((i >> 8) & 255) / 255.0,
-               ((i) & 255) / 255.0 ];
+        ((i >> 8) & 255) / 255.0,
+        ((i) & 255) / 255.0 ];
     });
     const last = colours.length - 1;
     return (value => {
       const m = value * last;
       if (m >= last) {

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

     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;
+      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() {

     if (!extracted.hasOwnProperty('features')
       || !extracted.hasOwnProperty('outputDescriptor')) {
       return;
     }
     if (!extracted.features.hasOwnProperty('shape')
-      || !extracted.features.hasOwnProperty('data')) {
+      || !extracted.features.hasOwnProperty('collected')) {
       return;
     }
     const features: FeatureCollection = (extracted.features as FeatureCollection);
     const outputDescriptor = extracted.outputDescriptor;
     // const height = this.trackDiv.nativeElement.getBoundingClientRect().height / 2;
     const height = this.trackDiv.nativeElement.getBoundingClientRect().height;
     const waveTrack = this.timeline.getTrackById(`wave-${this.trackIdPrefix}`);
 
     // TODO refactor all of this
     switch (features.shape) {
-    case 'vector': {
-	const collected = features.collected as VectorFeatures;
+      case 'vector': {
+        const collected = features.collected as VectorFeatures;
         const stepDuration = collected.stepDuration;
         const featureData = collected.data;
         if (featureData.length === 0) {
           return;
         }

         let max = featureData.reduce((m, f) => Math.max(m, f), -Infinity);
         if (min === Infinity) {
           min = 0;
           max = 1;
         }
-	console.log("adding line layer: min = " + min + ", max = " + max);
-	if (min !== min || max !== max) {
-	  console.log("WARNING: min or max is NaN");
-	  min = 0;
-	  max = 1;
-	}
+        console.log('adding line layer: min = ' + min + ', max = ' + max);
+        if (min !== min || max !== max) {
+          console.log('WARNING: min or max is NaN');
+          min = 0;
+          max = 1;
+        }
         const lineLayer = new wavesUI.helpers.LineLayer(plotData, {
           color: colour,
           height: height,
           yDomain: [ min, max ]
         });

           this.timeline.timeContext
         );
         break;
       }
       case 'list': {
-	const featureData = features.collected as FeatureList;
+        const featureData = features.collected as FeatureList;
         if (featureData.length === 0) {
           return;
         }
         // TODO look at output descriptor instead of directly inspecting features
         const hasDuration = outputDescriptor.configured.hasDuration;

           && outputDescriptor.configured.binCount === 0
           && featureData[0].featureValues == null;
         const isRegion = hasDuration
           && featureData[0].timestamp != null;
         console.log('Have list features: length ' + featureData.length +
-                    ', isMarker ' + isMarker + ', isRegion ' + isRegion +
-                    ', hasDuration ' + hasDuration);
+          ', isMarker ' + isMarker + ', isRegion ' + isRegion +
+          ', hasDuration ' + hasDuration);
         // TODO refactor, this is incomprehensible
         if (isMarker) {
           const plotData = featureData.map(feature => ({
             time: toSeconds(feature.timestamp),
             label: feature.label

           );
         }
         break;
       }
       case 'matrix': {
-	const collected = features.collected as MatrixFeatures;
+        const collected = features.collected as MatrixFeatures;
         const stepDuration = collected.stepDuration;
         // !!! + start time
         const matrixData = collected.data;
 
         if (matrixData.length === 0) {

         console.log('matrix data length = ' + matrixData.length);
         console.log('height of first column = ' + matrixData[0].length);
         const targetValue = this.estimatePercentile(matrixData, 95);
         const gain = (targetValue > 0.0 ? (1.0 / targetValue) : 1.0);
         console.log('setting gain to ' + gain);
-        const matrixEntity =
-          new wavesUI.utils.PrefilledMatrixEntity(matrixData,
-                                                  0, // startTime
-                                                  stepDuration);
+        const matrixEntity = new wavesUI.utils.PrefilledMatrixEntity(
+            matrixData,
+            0, // startTime
+            stepDuration
+          );
         const matrixLayer = new wavesUI.helpers.MatrixLayer(matrixEntity, {
           gain,
           top: 0,
           height: height,
           normalise: 'none',

         // this kinda logic should also be tested
         const mustPageForward = offsetTimestamp > visibleDuration;
         const mustPageBackward = currentTime < -currentOffset;
 
         if (mustPageForward) {
-          const hasSkippedMultiplePages = offsetTimestamp - visibleDuration > visibleDuration;
-
-            this.timeline.timeContext.offset = hasSkippedMultiplePages ?
-                -currentTime +  0.5 * visibleDuration :
-                currentOffset - visibleDuration;
+          const hasSkippedMultiplePages = offsetTimestamp -
+            visibleDuration > visibleDuration;
+
+          this.timeline.timeContext.offset = hasSkippedMultiplePages ?
+            -currentTime +  0.5 * visibleDuration :
+            currentOffset - visibleDuration;
           this.timeline.tracks.update();
         }
 
         if (mustPageBackward) {
-          const hasSkippedMultiplePages = currentTime + visibleDuration < -currentOffset;
-            this.timeline.timeContext.offset = hasSkippedMultiplePages ?
-                -currentTime + 0.5 * visibleDuration :
-                currentOffset + visibleDuration;
+          const hasSkippedMultiplePages = currentTime +
+            visibleDuration < -currentOffset;
+          this.timeline.timeContext.offset = hasSkippedMultiplePages ?
+            -currentTime + 0.5 * visibleDuration :
+            currentOffset + visibleDuration;
           this.timeline.tracks.update();
         }
 
         if (this.isPlaying) {
           requestAnimationFrame(updateSeekingCursor);