From 9ae8ca2e3ce1df26f5aee8774ee4dcec9e220540 Mon Sep 17 00:00:00 2001 From: Luis Fernando Molina Date: Thu, 21 Feb 2019 12:08:59 +0100 Subject: [PATCH] 2 Plotters Working, reading the same file --- BollingerBands.js | 14 +- PercentageBandwidth.js | 811 +++++++++++++++++++++++++++++++++++++++ this.plotter.config.json | 8 + 3 files changed, 829 insertions(+), 4 deletions(-) create mode 100644 PercentageBandwidth.js diff --git a/BollingerBands.js b/BollingerBands.js index cce97f783..5630c367c 100644 --- a/BollingerBands.js +++ b/BollingerBands.js @@ -286,14 +286,16 @@ let band = { begin: undefined, end: undefined, + close: undefined, movingAverage: undefined, standardDeviation: undefined }; band.begin = dailyFile[i][0]; band.end = dailyFile[i][1]; - band.movingAverage = dailyFile[i][2]; - band.standardDeviation = dailyFile[i][3]; + band.close = dailyFile[i][2]; + band.movingAverage = dailyFile[i][3]; + band.standardDeviation = dailyFile[i][4]; if (band.begin >= farLeftDate.valueOf() && band.end <= farRightDate.valueOf()) { @@ -361,14 +363,16 @@ let band = { begin: undefined, end: undefined, + close: undefined, movingAverage: undefined, standardDeviation: undefined }; band.begin = marketFile[i][0]; band.end = marketFile[i][1]; - band.movingAverage = marketFile[i][2]; - band.standardDeviation = marketFile[i][3]; + band.close = marketFile[i][2]; + band.movingAverage = marketFile[i][3]; + band.standardDeviation = marketFile[i][4]; if (band.begin >= leftDate.valueOf() && band.end <= rightDate.valueOf()) { @@ -462,6 +466,8 @@ band = bands[i]; previousBand = bands[i - 1]; + /* From here we draw the actual Bollinger Bands and lines it contains. */ + let bandPoint1 = { x: band.begin, y: previousBand.movingAverage - 2 * previousBand.standardDeviation diff --git a/PercentageBandwidth.js b/PercentageBandwidth.js new file mode 100644 index 000000000..9dcea97f2 --- /dev/null +++ b/PercentageBandwidth.js @@ -0,0 +1,811 @@ +function newAAMastersPlottersBollingerBandsPercentageBandwidth () { + + const MODULE_NAME = "Bands Plotter"; + const INFO_LOG = false; + const ERROR_LOG = true; + const INTENSIVE_LOG = false; + const logger = newWebDebugLog(); + logger.fileName = MODULE_NAME; + + let thisObject = { + + // Main functions and properties. + + initialize: initialize, + container: undefined, + getContainer: getContainer, + setTimePeriod: setTimePeriod, + setDatetime: setDatetime, + draw: draw, + recalculateScale: recalculateScale, + + /* Events declared outside the plotter. */ + + onDailyFileLoaded: onDailyFileLoaded, + + // Secondary functions and properties. + + currentBand: undefined + }; + + /* this is part of the module template */ + + let container = newContainer(); // Do not touch this 3 lines, they are just needed. + container.initialize(); + thisObject.container = container; + + let plotAreaFrame = newTimeLineCoordinateSystem(); // Used for full frame view. + let plotAreaViewport = newTimeLineCoordinateSystem(); // Used for viewport view. + + let timePeriod; // This will hold the current Time Period the user is at. + let datetime; // This will hold the current Datetime the user is at. + + let marketFile; // This is the current Market File being plotted. + let fileCursor; // This is the current File Cursor being used to retrieve Daily Files. + + let marketFiles; // This object will provide the different Market Files at different Time Periods. + let dailyFiles; // This object will provide the different File Cursors at different Time Periods. + + /* these are module specific variables: */ + + let bands = []; // Here we keep the bands to be ploted every time the Draw() function is called by the AAWebPlatform. + + return thisObject; + + function initialize(pStorage, pExchange, pMarket, pDatetime, pTimePeriod, callBackFunction) { + + try { + + if (INFO_LOG === true) { logger.write("[INFO] initialize -> Entering function."); } + + /* Store the information received. */ + + marketFiles = pStorage.marketFiles[0]; + dailyFiles = pStorage.dailyFiles[0]; + + datetime = pDatetime; + timePeriod = pTimePeriod; + + /* We need a Market File in order to calculate the Y scale, since this scale depends on actual data. */ + + marketFile = marketFiles.getFile(ONE_DAY_IN_MILISECONDS); // This file is the one processed faster. + + recalculateScaleY(); + recalculateScaleX(); + + /* Now we set the right files according to current Period. */ + + marketFile = marketFiles.getFile(pTimePeriod); + fileCursor = dailyFiles.getFileCursor(pTimePeriod); + + /* Listen to the necesary events. */ + + viewPort.eventHandler.listenToEvent("Zoom Changed", onZoomChanged); + viewPort.eventHandler.listenToEvent("Offset Changed", onOffsetChanged); + marketFiles.eventHandler.listenToEvent("Files Updated", onFilesUpdated); + canvas.eventHandler.listenToEvent("Drag Finished", onDragFinished); + + /* Get ready for plotting. */ + + recalculate(); + + callBackFunction(); + + } catch (err) { + + if (ERROR_LOG === true) { logger.write("[ERROR] initialize -> err.message = " + err.message); } + } + } + + function recalculateScale () { + + recalculateScaleY(); + recalculateScaleX(); + + } + + function getContainer(point) { + + try { + + if (INFO_LOG === true) { logger.write("[INFO] getContainer -> Entering function."); } + + let container; + + /* First we check if this point is inside this space. */ + + if (this.container.frame.isThisPointHere(point) === true) { + + return this.container; + + } else { + + /* This point does not belong to this space. */ + + return undefined; + } + + } catch (err) { + + if (ERROR_LOG === true) { logger.write("[ERROR] getContainer -> err.message = " + err.message); } + } + } + + function onFilesUpdated() { + + try { + + if (INFO_LOG === true) { logger.write("[INFO] onFilesUpdated -> Entering function."); } + + let newMarketFile = marketFiles.getFile(timePeriod); + + if (newMarketFile !== undefined) { + + marketFile = newMarketFile; + recalculate(); + } + + } catch (err) { + + if (ERROR_LOG === true) { logger.write("[ERROR] onFilesUpdated -> err.message = " + err.message); } + } + } + + function setTimePeriod(pTimePeriod) { + + try { + + if (INFO_LOG === true) { logger.write("[INFO] setTimePeriod -> Entering function."); } + + if (timePeriod !== pTimePeriod) { + + timePeriod = pTimePeriod; + + if (timePeriod >= _1_HOUR_IN_MILISECONDS) { + + let newMarketFile = marketFiles.getFile(pTimePeriod); + + if (newMarketFile !== undefined) { + + marketFile = newMarketFile; + recalculate(); + } + + } else { + + let newFileCursor = dailyFiles.getFileCursor(pTimePeriod); + + if (newFileCursor !== undefined) { + + fileCursor = newFileCursor; + recalculate(); + } + } + } + + } catch (err) { + + if (ERROR_LOG === true) { logger.write("[ERROR] setTimePeriod -> err.message = " + err.message); } + } + } + + function setDatetime(pDatetime) { + + if (INFO_LOG === true) { logger.write("[INFO] setDatetime -> Entering function."); } + + datetime = pDatetime; + + } + + function onDailyFileLoaded(event) { + + try { + + if (INFO_LOG === true) { logger.write("[INFO] onDailyFileLoaded -> Entering function."); } + + if (event.currentValue === event.totalValue) { + + /* This happens only when all of the files in the cursor have been loaded. */ + + recalculate(); + + } + + } catch (err) { + + if (ERROR_LOG === true) { logger.write("[ERROR] onDailyFileLoaded -> err.message = " + err.message); } + } + } + + function draw() { + + try { + + if (INTENSIVE_LOG === true) { logger.write("[INFO] draw -> Entering function."); } + + this.container.frame.draw(); + + plotChart(); + + } catch (err) { + + if (ERROR_LOG === true) { logger.write("[ERROR] draw -> err.message = " + err.message); } + } + } + + function recalculate() { + + try { + + if (INFO_LOG === true) { logger.write("[INFO] recalculate -> Entering function."); } + + if (timePeriod >= _1_HOUR_IN_MILISECONDS) { + + recalculateUsingMarketFiles(); + + } else { + + recalculateUsingDailyFiles(); + + } + + thisObject.container.eventHandler.raiseEvent("Bands Changed", bands); + + } catch (err) { + + if (ERROR_LOG === true) { logger.write("[ERROR] recalculate -> err.message = " + err.message); } + } + } + + function recalculateUsingDailyFiles() { + + try { + + if (INFO_LOG === true) { logger.write("[INFO] recalculateUsingDailyFiles -> Entering function."); } + + if (fileCursor === undefined) { return; } // We need to wait + + if (fileCursor.files.size === 0) { return; } // We need to wait until there are files in the cursor + + let daysOnSides = getSideDays(timePeriod); + + let leftDate = getDateFromPoint(viewPort.visibleArea.topLeft, thisObject.container, plotAreaFrame); + let rightDate = getDateFromPoint(viewPort.visibleArea.topRight, thisObject.container, plotAreaFrame); + + let dateDiff = rightDate.valueOf() - leftDate.valueOf(); + + let farLeftDate = new Date(leftDate.valueOf() - dateDiff * 1.5); + let farRightDate = new Date(rightDate.valueOf() + dateDiff * 1.5); + + let currentDate = new Date(farLeftDate.valueOf()); + + bands = []; + + while (currentDate.valueOf() <= farRightDate.valueOf() + ONE_DAY_IN_MILISECONDS) { + + let stringDate = currentDate.getFullYear() + '-' + pad(currentDate.getMonth() + 1, 2) + '-' + pad(currentDate.getDate(), 2); + + let dailyFile = fileCursor.files.get(stringDate); + + if (dailyFile !== undefined) { + + for (let i = 0; i < dailyFile.length; i++) { + + let band = { + begin: undefined, + end: undefined, + close: undefined, + movingAverage: undefined, + standardDeviation: undefined + }; + + band.begin = dailyFile[i][0]; + band.end = dailyFile[i][1]; + band.close = dailyFile[i][2]; + band.movingAverage = dailyFile[i][3]; + band.standardDeviation = dailyFile[i][4]; + + if (band.begin >= farLeftDate.valueOf() && band.end <= farRightDate.valueOf()) { + + bands.push(band); + + if (datetime.valueOf() >= band.begin && datetime.valueOf() <= band.end) { + + thisObject.currentBand = band; + thisObject.container.eventHandler.raiseEvent("Current Band Changed", thisObject.currentBand); + + } + } + } + } + + currentDate = new Date(currentDate.valueOf() + ONE_DAY_IN_MILISECONDS); + } + + /* Lests check if all the visible screen is going to be covered by bands. */ + + let lowerEnd = leftDate.valueOf(); + let upperEnd = rightDate.valueOf(); + + if (bands.length > 0) { + + if (bands[0].begin > lowerEnd || bands[bands.length - 1].end < upperEnd) { + + setTimeout(recalculate, 2000); + + //console.log("File missing while calculating bands, scheduling a recalculation in 2 seconds."); + + } + } + + //console.log("Olivia > recalculateUsingDailyFiles > total bands generated : " + bands.length); + + } catch (err) { + + if (ERROR_LOG === true) { logger.write("[ERROR] recalculateUsingDailyFiles -> err.message = " + err.message); } + } + } + + function recalculateUsingMarketFiles() { + + try { + + if (INFO_LOG === true) { logger.write("[INFO] recalculateUsingMarketFiles -> Entering function."); } + + if (marketFile === undefined) { return; } // Initialization not complete yet. + + let daysOnSides = getSideDays(timePeriod); + + let leftDate = getDateFromPoint(viewPort.visibleArea.topLeft, thisObject.container, plotAreaFrame); + let rightDate = getDateFromPoint(viewPort.visibleArea.topRight, thisObject.container, plotAreaFrame); + + let dateDiff = rightDate.valueOf() - leftDate.valueOf(); + + leftDate = new Date(leftDate.valueOf() - dateDiff * 1.5); + rightDate = new Date(rightDate.valueOf() + dateDiff * 1.5); + + bands = []; + + for (let i = 0; i < marketFile.length; i++) { + + let band = { + begin: undefined, + end: undefined, + close: undefined, + movingAverage: undefined, + standardDeviation: undefined + }; + + band.begin = marketFile[i][0]; + band.end = marketFile[i][1]; + band.close = marketFile[i][2]; + band.movingAverage = marketFile[i][3]; + band.standardDeviation = marketFile[i][4]; + + if (band.begin >= leftDate.valueOf() && band.end <= rightDate.valueOf()) { + + bands.push(band); + + if (datetime.valueOf() >= band.begin && datetime.valueOf() <= band.end) { + + thisObject.currentBand = band; + thisObject.container.eventHandler.raiseEvent("Current Band Changed", thisObject.currentBand); + + } + } + } + + //console.log("Olivia > recalculateUsingMarketFiles > total bands generated : " + bands.length); + + } catch (err) { + + if (ERROR_LOG === true) { logger.write("[ERROR] recalculateUsingMarketFiles -> err.message = " + err.message); } + } + } + + function recalculateScaleX() { + + try { + + if (INFO_LOG === true) { logger.write("[INFO] recalculateScaleX -> Entering function."); } + + var minValue = { + x: EARLIEST_DATE.valueOf() + }; + + var maxValue = { + x: MAX_PLOTABLE_DATE.valueOf() + }; + + plotAreaViewport.initializeX( + minValue, + maxValue, + thisObject.container.frame.width + ); + + plotAreaFrame.initializeX( + minValue, + maxValue, + thisObject.container.frame.width + ); + + } catch (err) { + + if (ERROR_LOG === true) { logger.write("[ERROR] recalculateScaleX -> err.message = " + err.message); } + } + } + + function recalculateScaleY() { + + try { + + if (INFO_LOG === true) { logger.write("[INFO] recalculateScaleY -> Entering function."); } + + var minValue = { + y: 0 + }; + + var maxValue = { + y: 0 + }; + + maxValue.y = 100; + + plotAreaViewport.initializeY( + minValue, + maxValue, + viewPort.visibleArea.bottomRight.y - viewPort.visibleArea.topLeft.y + ); + + plotAreaFrame.initializeY( + minValue, + maxValue, + thisObject.container.frame.height + ); + + } catch (err) { + + if (ERROR_LOG === true) { logger.write("[ERROR] recalculateScaleY -> err.message = " + err.message); } + } + } + + + function plotChart() { + + try { + + if (INTENSIVE_LOG === true) { logger.write("[INFO] plotChart -> Entering function."); } + + let band; + let previousBand; + + if (bands.length > 0) { + + /* This next section is to get ready in order to be able to plot dinamically constrained to the viewport */ + + let visibleHeight = viewPort.visibleArea.bottomRight.y - viewPort.visibleArea.topLeft.y; + + let frameCorner1 = { + x: 0, + y: 0 + }; + + let frameCorner2 = { + x: thisObject.container.frame.width, + y: thisObject.container.frame.height + }; + + /* Now the transformations. */ + + frameCorner1 = transformThisPoint(frameCorner1, thisObject.container.frame.container); + frameCorner2 = transformThisPoint(frameCorner2, thisObject.container.frame.container); + + let frameHeightInViewPort = frameCorner2.y - frameCorner1.y; + let pbChartHeight = 20; + let pbOffset = 100 / 5 * 4; + + /* Now we calculate and plot the bands */ + + for (let i = 1; i < bands.length; i++) { + + band = bands[i]; + previousBand = bands[i - 1]; + + /* Here we will draw the percent bandwidth chart */ + + let lowerBB; + let upperBB; + + lowerBB = band.movingAverage - 2 * band.standardDeviation; + upperBB = band.movingAverage + 2 * band.standardDeviation; + + let currentPercentBandwidth = (band.close - lowerBB) / (upperBB - lowerBB) * pbChartHeight; + if (currentPercentBandwidth > pbChartHeight) { currentPercentBandwidth = pbChartHeight }; + if (currentPercentBandwidth < 0) { currentPercentBandwidth = 0 }; + + lowerBB = previousBand.movingAverage - 2 * previousBand.standardDeviation; + upperBB = previousBand.movingAverage + 2 * previousBand.standardDeviation; + + let previousPercentBandwidth = (previousBand.close - lowerBB) / (upperBB - lowerBB) * pbChartHeight; + if (previousPercentBandwidth > pbChartHeight) { previousPercentBandwidth = pbChartHeight }; + if (previousPercentBandwidth < 0) { previousPercentBandwidth = 0 }; + + let pbPoint1; + let pbPoint2; + let pbPoint3; + let pbPoint4; + let pbPoint5; + let pbPoint6; + + function calculateCoordinates(plot, height) { + + pbPoint1 = { + x: band.begin, + y: previousPercentBandwidth + pbOffset + }; + + pbPoint2 = { + x: band.end, + y: currentPercentBandwidth + pbOffset + }; + + /* Points needed for the lines */ + + pbPoint3 = { + x: 0, + y: 0 * pbChartHeight / 100 + pbOffset + }; + + pbPoint4 = { + x: 0, + y: 30 * pbChartHeight / 100 + pbOffset + }; + + pbPoint5 = { + x: 0, + y: 70 * pbChartHeight / 100 + pbOffset + }; + + pbPoint6 = { + x: 0, + y: 100 * pbChartHeight / 100 + pbOffset + }; + + pbPoint1 = plot.transformThisPoint(pbPoint1); + pbPoint2 = plot.transformThisPoint(pbPoint2); + + pbPoint3 = plot.transformThisPoint(pbPoint3); + pbPoint4 = plot.transformThisPoint(pbPoint4); + pbPoint5 = plot.transformThisPoint(pbPoint5); + pbPoint6 = plot.transformThisPoint(pbPoint6); + + pbPoint1 = transformThisPoint(pbPoint1, thisObject.container); + pbPoint2 = transformThisPoint(pbPoint2, thisObject.container); + + pbPoint3 = transformThisPoint(pbPoint3, thisObject.container); + pbPoint4 = transformThisPoint(pbPoint4, thisObject.container); + pbPoint5 = transformThisPoint(pbPoint5, thisObject.container); + pbPoint6 = transformThisPoint(pbPoint6, thisObject.container); + + if (pbPoint1.x < viewPort.visibleArea.bottomLeft.x || pbPoint2.x > viewPort.visibleArea.bottomRight.x) { + return false; + } + + return true; + + } + + if (calculateCoordinates(plotAreaFrame, thisObject.container.frame.height) === false) { continue; } // We try to see if it fits in the visible area. + + if (frameHeightInViewPort > visibleHeight * 2 / 3) { + + if (calculateCoordinates(plotAreaViewport, visibleHeight) === false) { + continue; + } // We snap t to the view port. + + /* Now we set the real value of y. */ + + pbPoint1.y = viewPort.visibleArea.bottomRight.y - (previousPercentBandwidth + pbOffset) * plotAreaViewport.scale.y; + pbPoint2.y = viewPort.visibleArea.bottomRight.y - (currentPercentBandwidth + pbOffset) * plotAreaViewport.scale.y; + + pbPoint3.y = viewPort.visibleArea.bottomRight.y - (0 * pbChartHeight / 100 + pbOffset) * plotAreaViewport.scale.y; + pbPoint4.y = viewPort.visibleArea.bottomRight.y - (30 * pbChartHeight / 100 + pbOffset) * plotAreaViewport.scale.y; + pbPoint5.y = viewPort.visibleArea.bottomRight.y - (70 * pbChartHeight / 100 + pbOffset) * plotAreaViewport.scale.y; + pbPoint6.y = viewPort.visibleArea.bottomRight.y - (100 * pbChartHeight / 100 + pbOffset) * plotAreaViewport.scale.y; + + } + + /* Everything must fit within the visible area */ + + pbPoint1 = viewPort.fitIntoVisibleArea(pbPoint1); + pbPoint2 = viewPort.fitIntoVisibleArea(pbPoint2); + + pbPoint3 = viewPort.fitIntoVisibleArea(pbPoint3); + pbPoint4 = viewPort.fitIntoVisibleArea(pbPoint4); + pbPoint5 = viewPort.fitIntoVisibleArea(pbPoint5); + pbPoint6 = viewPort.fitIntoVisibleArea(pbPoint6); + + + /* Now the drawing of the lines */ + + let bgOpacityA = 0.05; + let bgOpacityB = 0.05; + let bgOpacityC = 0.05; + + let fgOpacity = '1'; + + let lineWidthA = 0.2; + let lineWidthB = 0.2; + let lineWidthC = 0.2; + + if (pbPoint1.y > pbPoint4.y || pbPoint2.y > pbPoint4.y) { + bgOpacityA = bgOpacityA * 2; + } + + if (pbPoint1.y < pbPoint5.y || pbPoint2.y < pbPoint5.y) { + bgOpacityC = bgOpacityC * 2; + } + + if (pbPoint1.y >= pbPoint3.y || pbPoint2.y >= pbPoint3.y) { + bgOpacityA = bgOpacityA * 1.5; + lineWidthA = lineWidthA * 2; + } + + if (pbPoint1.y <= pbPoint6.y || pbPoint2.y <= pbPoint6.y) { + bgOpacityC = bgOpacityC * 1.5; + lineWidthC = lineWidthC * 2; + } + + browserCanvasContext.beginPath(); + + browserCanvasContext.moveTo(pbPoint1.x, pbPoint3.y); + browserCanvasContext.lineTo(pbPoint2.x, pbPoint3.y); + browserCanvasContext.lineTo(pbPoint2.x, pbPoint4.y); + browserCanvasContext.lineTo(pbPoint1.x, pbPoint4.y); + + browserCanvasContext.closePath(); + + browserCanvasContext.fillStyle = 'rgba(' + UI_COLOR.GOLDEN_ORANGE + ',' + bgOpacityA + ' )'; + browserCanvasContext.fill(); + + browserCanvasContext.beginPath(); + + browserCanvasContext.moveTo(pbPoint1.x, pbPoint4.y); + browserCanvasContext.lineTo(pbPoint2.x, pbPoint4.y); + browserCanvasContext.lineTo(pbPoint2.x, pbPoint5.y); + browserCanvasContext.lineTo(pbPoint1.x, pbPoint5.y); + + browserCanvasContext.closePath(); + + browserCanvasContext.fillStyle = 'rgba(' + UI_COLOR.TITANIUM_YELLOW + ', ' + bgOpacityB + ')'; + browserCanvasContext.fill(); + + browserCanvasContext.beginPath(); + + browserCanvasContext.moveTo(pbPoint1.x, pbPoint5.y); + browserCanvasContext.lineTo(pbPoint2.x, pbPoint5.y); + browserCanvasContext.lineTo(pbPoint2.x, pbPoint6.y); + browserCanvasContext.lineTo(pbPoint1.x, pbPoint6.y); + + browserCanvasContext.closePath(); + + browserCanvasContext.fillStyle = 'rgba(' + UI_COLOR.GOLDEN_ORANGE + ', ' + bgOpacityC + ')'; + browserCanvasContext.fill(); + + browserCanvasContext.beginPath(); + + browserCanvasContext.moveTo(pbPoint1.x, pbPoint3.y); + browserCanvasContext.lineTo(pbPoint2.x, pbPoint3.y); + + browserCanvasContext.closePath(); + + browserCanvasContext.strokeStyle = 'rgba(' + UI_COLOR.GOLDEN_ORANGE + ', ' + fgOpacity + ')'; + browserCanvasContext.lineWidth = lineWidthA; + browserCanvasContext.stroke(); + + browserCanvasContext.beginPath(); + + browserCanvasContext.moveTo(pbPoint1.x, pbPoint4.y); + browserCanvasContext.lineTo(pbPoint2.x, pbPoint4.y); + browserCanvasContext.moveTo(pbPoint1.x, pbPoint5.y); + browserCanvasContext.lineTo(pbPoint2.x, pbPoint5.y); + + browserCanvasContext.closePath(); + + browserCanvasContext.strokeStyle = 'rgba(' + UI_COLOR.GOLDEN_ORANGE + ', ' + fgOpacity + ')'; + browserCanvasContext.lineWidth = lineWidthB; + browserCanvasContext.stroke(); + + browserCanvasContext.beginPath(); + + browserCanvasContext.moveTo(pbPoint1.x, pbPoint6.y); + browserCanvasContext.lineTo(pbPoint2.x, pbPoint6.y); + + browserCanvasContext.closePath(); + + browserCanvasContext.strokeStyle = 'rgba(' + UI_COLOR.GOLDEN_ORANGE + ', ' + fgOpacity + ')'; + browserCanvasContext.lineWidth = lineWidthC; + browserCanvasContext.stroke(); + + /* Now the drawing of the percentage bandwidth*/ + + browserCanvasContext.beginPath(); + + browserCanvasContext.moveTo(pbPoint1.x, pbPoint1.y); + browserCanvasContext.lineTo(pbPoint2.x, pbPoint2.y); + + browserCanvasContext.closePath(); + + + if (datetime !== undefined) { + + let dateValue = datetime.valueOf(); + + if (dateValue >= band.begin && dateValue <= band.end) { + browserCanvasContext.strokeStyle = 'rgba(' + UI_COLOR.TITANIUM_YELLOW + ', 1)'; + } else { + browserCanvasContext.strokeStyle = 'rgba(' + UI_COLOR.GOLDEN_ORANGE + ', 1)'; + } + } else { + browserCanvasContext.strokeStyle = 'rgba(' + UI_COLOR.GOLDEN_ORANGE + ', 1)'; + } + + browserCanvasContext.lineWidth = 0.2; + browserCanvasContext.stroke(); + + } + } + + } catch (err) { + + if (ERROR_LOG === true) { logger.write("[ERROR] plotChart -> err.message = " + err.message); } + } + } + + + function onZoomChanged(event) { + + try { + + if (INFO_LOG === true) { logger.write("[INFO] onZoomChanged -> Entering function."); } + + recalculate(); + + } catch (err) { + + if (ERROR_LOG === true) { logger.write("[ERROR] onZoomChanged -> err.message = " + err.message); } + } + } + + function onOffsetChanged() { + + try { + + if (INFO_LOG === true) { logger.write("[INFO] onOffsetChanged -> Entering function."); } + + if (Math.random() * 100 > 95) { + + recalculate() + }; + + } catch (err) { + + if (ERROR_LOG === true) { logger.write("[ERROR] onOffsetChanged -> err.message = " + err.message); } + } + } + + function onDragFinished() { + + try { + + if (INFO_LOG === true) { logger.write("[INFO] onDragFinished -> Entering function."); } + + recalculate(); + + } catch (err) { + + if (ERROR_LOG === true) { logger.write("[ERROR] onDragFinished -> err.message = " + err.message); } + } + } +} + diff --git a/this.plotter.config.json b/this.plotter.config.json index a5e787874..8edbd9306 100644 --- a/this.plotter.config.json +++ b/this.plotter.config.json @@ -15,6 +15,14 @@ "event": "Current Band Changed" } ] + }, + { + "codeName": "PercentageBandwidth", + "moduleName": "PercentageBandwidth", + "description": "Plots Bollinger Bands.", + "profilePicture": "PercentageBandwidth.png", + "panels": [ + ] } ] } \ No newline at end of file