• Das Erstellen neuer Accounts wurde ausgesetzt. Bei berechtigtem Interesse bitte Kontaktaufnahme über die üblichen Wege. Beste Grüße der Admin

Farblegende funktioniert nicht ganz

xorg1990

New member
Hi, ich habe ein neues Problem aber diesmal nicht so kompliziert als das letztere xD.

Ich möchte bein meinen Analyser eine Farblegende hinzufügen, so das man erkenne kann wie laut war den ein Signal.

Das Problem besteht darin das der Helligkeit slider nicht über alle Farben fährt.
Sprich wenn der Contrast slider das Gradient voll aufzoomt (slider ganz links), muss wenn der Brigthness slider ganz rechts ist die Legende weis sein.
Das ist nicht der Fall.
Richtig wäre das wenn der Helligkeitsregler nach links bewegt wird das jede Farbe einmal komplett in die Legende Passt. Ganz rechts Weis, ganz links Schwarz zwischendrine Farbe.

Das will mir nicht gelingen

Demo-Code:
Code:
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/html">

<head>
    <title>colorsclaehelper</title>
    <script type="text/javascript">
        var csh;
    function ready(){
        
function colorScaleHelper(ColorScalHelper_ClassID) {
    var canvas = document.getElementById(ColorScalHelper_ClassID);
    this.canvas_width = canvas.width;
    this.canvas_height = canvas.height;
    this.canvas_ctx = canvas.getContext("2d");
    this.canvas_ctx.imageSmoothingEnabled = false;
    this.colors = ['#000000', '#ff0000', '#ffff00', '#ffffff'];
    this.db_from = -120;
    this.db_to = 0;
    this.contrast = 70;
    this.brightness = 40;
    this.renderdBscale();
    this.renderColorScale();
}


colorScaleHelper.prototype.setdB = function(db_from, db_to) {
 this.db_from = db_from;
 this.db_to = db_to;
};

colorScaleHelper.prototype.setColors = function(colors) {
    this.colors = colors;
    this.renderColorScale();
};

colorScaleHelper.prototype.setBrigthness = function(bright) {
    this.brightness = bright*-1;
    this.renderColorScale();
};

colorScaleHelper.prototype.setContrast = function(con) {
    this.contrast = con*-1;
    this.renderColorScale();
};

colorScaleHelper.prototype.renderColorScale = function() {
    this.canvas_ctx.clearRect(0, 0, this.canvas_width, this.canvas_height - 25);
    var xoffs =  this.brightness*this.canvas_width/100;
    var grdWidth =  this.contrast*(this.canvas_width*this.colors.length)/100;
    var firstColor = this.colors[0];
    
    var grd =  this.canvas_ctx.createLinearGradient(xoffs,0,grdWidth+xoffs,0);
    for (var i = 0; i < this.colors.length; i++) {
        var xcolorSpan = i*1.0/this.colors.length;
        grd.addColorStop(xcolorSpan, this.colors[i]);
    }

     this.canvas_ctx.fillStyle = firstColor;
     this.canvas_ctx.fillRect(0, 0, xoffs, this.canvas_height - 25);
     this.canvas_ctx.fillStyle = grd;
     this.canvas_ctx.fillRect(xoffs, 0, this.canvas_width, this.canvas_height - 25);
    
};


colorScaleHelper.prototype.renderdBscale = function() {

    var width = this.canvas_width;
    var beginn = 30;
     this.canvas_ctx.clearRect(0,  beginn, this.canvas_width,25);
     this.canvas_ctx.fillStyle = "white";
     this.canvas_ctx.fillRect(0,  beginn, this.canvas_width, 25);
     this.canvas_ctx.strokeStyle = "black";
     this.canvas_ctx.font = "12px Calibri";
     this.canvas_ctx.fillStyle = "black";
    var ticks = 25;
    var dBs = this.db_from - this.db_to;
    var xSpan = this.canvas_width / ticks;
    var steps = dBs / ticks;
    if (steps < 0) steps *= -1;
    var exp = Math.floor(Math.log(steps) / Math.LN10);
    var stepnorm = steps / Math.pow(10, exp);
    var schritt = Math.ceil(stepnorm * Math.pow(10, exp));
    var Numr = this.db_from;
    if (this.db_from < 0) Numr *= -1;
    for (var i = 0; i < ticks; i++, Numr -= schritt) {
        if (this.db_from < 0) {
            var string = Math.round(-Numr) + "";
        } else {
            var string = Math.round(Numr) + "";
        }
        var x = i * xSpan;
        if ((i % 2) == 0) {
             this.canvas_ctx.moveTo(x,  beginn);
             this.canvas_ctx.lineTo(x,  beginn+8);

        } else {
             this.canvas_ctx.moveTo(x,  beginn);
             this.canvas_ctx.lineTo(x,  beginn+6);
        }
        if (i == 5) {
             this.canvas_ctx.moveTo(x,  beginn);
             this.canvas_ctx.lineTo(x,  beginn+12);
             this.canvas_ctx.fillText(string, x - string.length * 4,  beginn+12 + 9);
        }
        if (i == 14) {
             this.canvas_ctx.moveTo(x,  beginn);
             this.canvas_ctx.lineTo(x,  beginn+12);
             this.canvas_ctx.fillText(string, x - string.length * 4,  beginn+12 + 9);
        }
        if (i == 24) {
             this.canvas_ctx.moveTo(x,  beginn);
             this.canvas_ctx.lineTo(x,  beginn+12);
             this.canvas_ctx.fillText(string, x - string.length * 4,  beginn+12 + 9);
        }


    }
    this.canvas_ctx.lineWidth = 1;
     this.canvas_ctx.stroke();
};
csh = new colorScaleHelper("canvas");
    }


    </script>
</head>

<body onload="ready()">
    <p><input type="range" min="-100" max="0" step="1" onchange="csh.setBrigthness(this.value)" />Brightness</p>
     <p><input type="range" min="-100" max="0" step="1" onchange="csh.setContrast(this.value)" />Contrast</p>
    <p><canvas id="canvas" width="150" height="55"></canvas></p>

</body>

</html>

Der CrysisCore ist das erste fillRect this.canvas_ctx.fillRect(0, 0, xoffs, this.canvas_height - 25);

Da beginne ich immer bei 0. Habe schon versucht die grdWidth wider abzuziehen aber das funzt auch nicht wirklich.

Asso die Slider habe ich invertiert. die Gehen von -100 bis 0 Prozent das möchte ich so.

Vielen Dank im voraus,
xorg1990
 
Das Problem besteht darin das der Helligkeit slider nicht über alle Farben fährt.
dazu müsste man(ich) erst mal wissen was genau du möchtest.

Sprich wenn der Contrast slider das Gradient voll aufzoomt (slider ganz links), muss wenn der Brigthness slider ganz rechts ist die Legende weis sein.
durchgängig? also nur weis?

Richtig wäre das wenn der Helligkeitsregler nach links bewegt wird das jede Farbe einmal komplett in die Legende Passt. Ganz rechts Weis, ganz links Schwarz zwischendrine Farbe.
dann würde ich das farbarray erst mal genau andersrum füllen

fangen wir mal von vorne an. erst mal ohne slider.
du hast 4 werte in deinem farbarray
this.colors = ['#000000', '#ff0000', '#ffff00', '#ffffff'];
das sind die werte die bei 0%, 33%, 66% und 100% deiner canvasbreite vorkommen sollen.
im bereich zw. 0% und 33% willst du einen interpolierten wert in den grenzen colors[0] und colors[1]
im bereich zw. 33% und 66% willst du einen interpolierten wert in den grenzen colors[1] und colors[2]
im bereich zw. 66% und 100% willst du einen interpolierten wert in den grenzen colors[2] und colors[3]

was willst du jetzt mit dem helligkeitsregler?
was willst du jetzt mit dem Kontrastregler?
 
Hallo tsseh.
tsseh schrieb:
durchgängig? also nur weis?
Durchgängig Ja. Weis ist es nur weil die Letzte Farbe im Array Weis ist, kann auch rot oder grün oder lila sein.

tsseh schrieb:
dann würde ich das farbarray erst mal genau andersrum füllen
Nee das entspricht ja nicht dem was der user eingegeben hat außerdem wäre das Gradient dann auch falsch rum.


tsseh schrieb:
im bereich zw. 0% und 33% willst du einen interpolierten wert in den grenzen colors[0] und colors[1]
im bereich zw. 33% und 66% willst du einen interpolierten wert in den grenzen colors[1] und colors[2]
im bereich zw. 66% und 100% willst du einen interpolierten wert in den grenzen colors[2] und colors[3]
?? nee das Gradient und der erste und letzte Wert im Array sind Ausschlaggebend.


tsseh schrieb:
was willst du jetzt mit dem helligkeitsregler?
was willst du jetzt mit dem Kontrastregler?

Das ist im Prinzip "ganz einfach".

Der Kontrastregler scheibt das Gradient zusammen oder weitet es auf. 1% ist ganz klein nur ein Farbklecks so zusagen und 100% wäre jede Farbe die im Array vorkommt passt einmal komplett in die Canvas width.


Der Helligkeitsregler verschiebt das Gradient.
Bei Helligkeit 0% ist alles nur noch weis (Weis deshalb weil es die letzte Farbe ist im array) und 100% wäre alles schwarz (Schwarz deshalb weil es die erste Farbe ist im Array).
Egal wie weit das Gradient aufgeweitet ist.

Beispiel:
Ist das Gradient voll aufgeweitet und der Helligkeitsregler ganz links sieht man schwarz, fährt man de reger dann in Richtung 0% kommt das Gradient durch Canvas gesaust bis bei 0% alles weis ist.

Man kann den Helligkeitsregler auch als Offset betrachten.

Problem, ich bekomme das Gradient immer nur nach rechts aus dem canvas geschoben nach links klappt es nicht.:mad:
 
Zuletzt bearbeitet:
?? nee das Gradient und der erste und letzte Wert im Array sind Ausschlaggebend.
dann bräuchtest du nur 2 felder in deinem array, so wie ich das beschrieben habe stimmt das schon

Der Kontrastregler scheibt das Gradient zusammen oder weitet es auf. 1% ist ganz klein nur ein Farbklecks so zusagen und 100% wäre jede Farbe die im Array vorkommt passt einmal komplett in die Canvas width.
du hast nur 4 farben in deinem array, zw. diesen wird interpoliert.
der Kontrastregler soll also die schrittweite festlegen. sprich Kontrastregler auf 1 bedeutet es sind nur 2 werte zulässig, 0 oder 1 also farbe auf array[0] oder farbe auf array[3]
du normierst also deine canvasbreite auf 0 bis Kontrastreglerwert und rundest auf integerwerte, also keine nachkommastellen.

Der Helligkeitsregler verschiebt das Gradient.
Bei Helligkeit 0% ist alles nur noch weis (Weis deshalb weil es die letzte Farbe ist im array) und 100% wäre alles schwarz (Schwarz deshalb weil es die letzte Farbe ist im Array).
hier fehlen noch ein paar informationen, auch hast du 2 mal "weil es die letzte Farbe ist im array".
mal angenommen bei 50% soll alles unverändert bleiben und bei 0 alles auf der farbe des array[0] und bei 100 alles auf der farbe des array[3] liegen, dann normierst du den Helligkeitsreglerwert auf -1 bis 1 und multiplizierst ihn mit dem Kontrastreglerwert und das ergebniss addierst du zum Kontrastreglerwert. dann musst du nur noch auf untere und obere grenze begrenzen.
sprich bei 0 hast du einen offset von -Kontrastreglerwert und deine werte in den grenzen von 0 bis Kontrastreglerwert gehen von -Kontrastreglerwert + 0 bis -Kontrastreglerwert + Kontrastreglerwert. durch die anpassung der ghrenzen also von 0 bis 0
bei 100 hast du einen offset von +Kontrastreglerwert und deine werte in den grenzen von 0 bis Kontrastreglerwert gehen von +Kontrastreglerwert + 0 bis +Kontrastreglerwert + Kontrastreglerwert. durch die anpassung der ghrenzen also von Kontrastreglerwert bis Kontrastreglerwert
 
tsseh schrieb:
dann bräuchtest du nur 2 felder in deinem array, so wie ich das beschrieben habe stimmt das schon
Warum nur 2 Felder? Das Array enthält die Farben aus denn sich das Gradient zusammen setzt.

tsseh schrieb:
. sprich Kontrastregler auf 1 bedeutet es sind nur 2 werte zulässig, 0 oder 1 also farbe auf array[0] oder farbe auf array[3]
Nee das Gradient setzt sich immer aus den Werten zusammen die im Array sind. Der Kontrastregler legt die Breite sprich das x1 Attribut der createLinearGradient Methode fest.

tsseh schrieb:
auch hast du 2 mal "weil es die letzte Farbe ist im array".
Ei, war ein copy paste Fehler. :beaten:

tsseh schrieb:
mal angenommen bei 50% soll alles unverändert bleiben
Bei 50% müsste/sollte genau die die mittle Farbmischung des Gradient's zu sehen sein, sprich das was zwischen '#ff0000', '#ffff00' Interpoliert wird. Das muss mittig im Canvas stehen, egal wie Breit das Gradient ist.


tsseh schrieb:
dann normierst du den Helligkeitsreglerwert auf -1 bis 1 und multiplizierst ihn mit dem Kontrastreglerwert und das ergebniss addierst du zum Kontrastreglerwert. dann musst du nur noch auf untere und obere grenze begrenzen.
Klingt ganz vernünftig, werde ich aber nicht mehr schaffen das einzugeben weil anderweitig arbeit ruft.
 
Warum nur 2 Felder? Das Array enthält die Farben aus denn sich das Gradient zusammen setzt.
ein gradient ist die (farb)änderung zw. 2 punkten/farben. von einer farbe zu einer anderen
du hast 3 gradienten einmal von 0-33%, dann von 33% zu 66% und von 66 zu 100

Nee das Gradient setzt sich immer aus den Werten zusammen die im Array sind. Der Kontrastregler legt die Breite sprich das x1 Attribut der createLinearGradient Methode fest.
der gradient setzt sich aus n-farben zusammen, du gibst start und zielfarbe an und musst zwischendurch interpolieren.
und soweit ich das verstanden habe, willst du mit dem Kontrastregler die schrittweite bestimmen.
sprich Kontrastregler auf auf 1 bedeutet du gehst von start zu zielfarbe in einem schritt, hast also nur farbe 0 und farbe 3
Kontrastregler auf 2 bedeutet du gehtst in 2 schritten, hast also farbe 0, farbe 1_2 und farbe 3 wobei farbe 1_2 die farbe ist welche zw. deinem arrayeintrag auf der hälfte zw. array-idx 1 und 2 liegt.
Kontrastregler auf 3 bedeutet du hast 4 farben, genau die, die du in deinem array angegeben hast.
...
Kontrastregler auf 100 bedeutet du hast 101 farbstufen in deinem verlauf.

Bei 50% müsste/sollte genau die die mittle Farbmischung des Gradient's zu sehen sein, sprich das was zwischen '#ff0000', '#ffff00' Interpoliert wird. Das muss mittig im Canvas stehen, egal wie Breit das Gradient ist.
das ergibt keinen sinn, bei 50% siehst du einen gradienten und nicht die "mittle Farbmischung" einen gradienten

- - - Aktualisiert - - -

Der Kontrastregler legt die Breite sprich das x1 Attribut der createLinearGradient Methode fest.
nein, den x1 parameter von createLinearGradient legt die canvasbreite fest
außerdem verstehe ich nicht ganz warum du hier nicht wieder mit deiner farb-bibliothek arbeitest, die du auch sonst nimmst. mit dieser färbst du ja deine kurven, dann solltest du die auch für die legende nutzen.
 
tsseh schrieb:
und soweit ich das verstanden habe, willst du mit dem Kontrastregler die schrittweite bestimmen.
sprich Kontrastregler auf auf 1 bedeutet du gehst von start zu zielfarbe in einem schritt, hast also nur farbe 0 und farbe 3
Der Kontrasregler soll wie schon mehrfach erwähnt das Gradient aufweiten oder zusammen fahren.
Würde ich da so machen wie du das beschreibst, dann überspringe ich ja Farben. Im Spektrogramm wären dann Farben zu sehen die in der Legende nicht existieren.
Das kann auch nicht richtig sein.
Ein anderer Fall wäre das das Gradient ist soweit aufgeweitet das es nicht mehr in die Legende passt und deshalb nicht alle Farben zu sehen sind.
Dann kommt der Helligkeitsregler ins Spiel wo man das Gradient als Ganzes verschieben kann so das es wider passt.

Ich habe wider eines meiner berühmten Katzenbilder für dich. Was ich sagen möchte so soll es am ende mal aussehen. Position der Regel ansehen.
slider.png


tsseh schrieb:
außerdem verstehe ich nicht ganz warum du hier nicht wieder mit deiner farb-bibliothek arbeitest, die du auch sonst nimmst. mit dieser färbst du ja deine kurven, dann solltest du die auch für die legende nutzen.
Weil am ende alles wider aufs selbe Problem hinaus läuft.
2tens müsste ich mir erst wider angucken wie man ein Linear Gradient über ChromaJS rendert. Die Canvas APi ist das simpler gestrickt.
 
Der Kontrasregler soll wie schon mehrfach erwähnt das Gradient aufweiten oder zusammen fahren.
also nicht die schrittweite? was dann? was bedeutet aufweiten?

Würde ich da so machen wie du das beschreibst, dann überspringe ich ja Farben.
ja, ich dachte das wolltest du, wobei ich dachte es wäre der helligkeitsregler und nicht der kontrast mit dem du das wolltest

Im Spektrogramm wären dann Farben zu sehen die in der Legende nicht existieren.
na du musst schon die farbwerte im Spektrogramm auch durch den helligkeits- und kontrastregler beeinflussen, die farben im Spektrogramm und in der legende müssen natürlich gleich berechnet werden

Ein anderer Fall wäre das das Gradient ist soweit aufgeweitet das es nicht mehr in die Legende passt und deshalb nicht alle Farben zu sehen sind.
nochmal, legende und Spektrogramm muss durch den selben algorithmus berechnet werden.

Dann kommt der Helligkeitsregler ins Spiel wo man das Gradient als Ganzes verschieben kann so das es wider passt.
wie wieder passt?

Weil am ende alles wider aufs selbe Problem hinaus läuft.
nee, bzw. ja es sollte so sein, dadurch dass du es unterschiedlich machst kann es aber nicht das selbe problem werden, sondern ein neues

2tens müsste ich mir erst wider angucken wie man ein Linear Gradient über ChromaJS rendert.
das machst du ja im Spektrogramm

Die Canvas APi ist das simpler gestrickt.
die canvas api unterstützt aber keine schrittweite, und das wolltest du, jedenfalls habe ich es so verstanden. willst du aber anscheinend nicht, also wieder alles auf anfang, was willst du mit den reglern?

- - - Aktualisiert - - -

wobei ich dachte es wäre der helligkeitsregler und nicht der kontrast mit dem du das wolltest
nee, war doch der kontrastregler, du wolltest:
Der Kontrastregler scheibt das Gradient zusammen oder weitet es auf. 1% ist ganz klein nur ein Farbklecks so zusagen und 100% wäre jede Farbe die im Array vorkommt passt einmal komplett in die Canvas width.
darunter verstehe ich
der Kontrastregler soll also die schrittweite festlegen. sprich Kontrastregler auf 1 bedeutet es sind nur 2 werte zulässig, 0 oder 1 also farbe auf array[0] oder farbe auf array[3]
ok, du willst bei 1 nicht einen schritt, sondern 1 farbe also legt der Kontrastregler die anzahl der vorkommenden farben fest =>
kontrastreglerwert = anzahl der punkte/farben = schrittweite - 1
kontrastreglerwert auf 1: nur farbe von array[0]
kontrastreglerwert auf 2: farbe von array[0] und array[3] kommt vor
kontrastreglerwert auf 100: über die canvasbreite werden 100 farbwerte interpoliert

Würde ich da so machen wie du das beschreibst, dann überspringe ich ja Farben.
doch nicht so wie oben? was heißt denn "überspringe ich ja Farben"?

jetzt lassen wir den helligkeitsregler erst mal weg und du sagst was der kontrastregler nun genau machen soll

- - - Aktualisiert - - -

Ich habe wider eines meiner berühmten Katzenbilder für dich. Was ich sagen möchte so soll es am ende mal aussehen. Position der Regel ansehen.
ja, du kannst nicht erwarten, dass wenn du hier irgendein bild einstellst, alles klar ist.
du versuchst irgendetwas nachzubauen, was du vermutlich selbst noch nicht verstanden hast, jedenfalls konntest du es bisher nicht beschreiben
das einzige was man(ich) ablesen kann ist, dass es tatsächlich nicht so funktionieren soll wie ich das bisher verstanden habe. ich hatte es so verstanden (chroma.js noch einbinden)
Code:
colorScaleHelper.prototype.renderColorScale = function()
{
  var colorScale = chroma.scale(['#000000', '#ff0000', '#ffff00', '#ffffff']).domain([0, this.contrast]).out('hex');
  this.canvas_ctx.clearRect(0, 0, this.canvas_width, this.canvas_height - 25);
  for (var i = 0; i < this.canvas_width; ++i)
  {
    var color = (this.contrast + 1) * i / this.canvas_width;
    color += this.contrast * (-1 + 2 * this.brightness / 100);
    color = Math.floor(color);
    if (color < 0)
    {
      color = 0;
    }
    else if (color > this.contrast)
    {
      color = this.contrast;
    }
    this.canvas_ctx.fillStyle = colorScale(color);
    this.canvas_ctx.fillRect(i, 0, 1, this.canvas_height - 25);
  }
};
das ist es aber nicht. was dann?
bleiben wir erst mal beim kontrast. was legt der fest?
 
tsseh schrieb:
also nicht die schrittweite? was dann? was bedeutet aufweiten?
Mit aufweiten meine ich die Länge des Gradient's verändern von (mal gesponnen) 5px, bis so lang das jede Farbe die im Array ist ein mal komplett in das Canvas passt.
Das max ist also 4*Canvas länge.


tsseh schrieb:
ja, ich dachte das wolltest du, wobei ich dachte es wäre der helligkeitsregler und nicht der kontrast mit dem du das wolltest
Nochmal, das Gradient wird immer mit allen Farben die im array vorkommen gerendert. auch wenn es über den Kontrastregler nur auf 5px länge eingestellt wurde.
Der Helligkeitsregler verschiebt das Gradient, wenn ein user das Gradient aber aus der Zeichenfläche herausschiebt dann kommt entweder nur schwarz oder nur weiß, das wird dann auch auf den Spektrum gerendert weil irgendwo ist das Limit erreicht. Das heißt aber noch lange nicht das, dass Gradient weg ist, es ist immer noch da man sieht es bloß nicht mehr.

tsseh schrieb:
nochmal, legende und Spektrogramm muss durch den selben algorithmus berechnet werden.
Schon klar deswegen baue ich ja die Geradengleichung ein mit Offset(Helligkeit) und Steigung(Kontrast) ein.



tsseh schrieb:
die canvas api unterstützt aber keine schrittweite,
addColorStop ist keine Schrittweite?

tsseh schrieb:
das ist es aber nicht. was dann?
bleiben wir erst mal beim kontrast. was legt der fest?
Nee das ist es nicht, bzw nicht ganz. Der Helligkeitsregler tut genau das was er tun soll!
Beim Kontrast hast du dich mit der Schrittweite verbissen, der Kontrasregler soll nur die Länge des Gradient's verändern. Wie ich schon erwähnte der x1 Wert der createLinearGradient methode.
Auch wenn das Gradient dann länger ist und über das Canvas raus ragt.


Das ganze wird dann sinnvoll wenn es um die Richtungsortung geht.
Dann wird das Gadient als Keis gerendert und ich kann via Kontrastregler + Helligkeitsregler z.b Signale die aus Norden oder woanders her kommen ausblenden.
Es gibt ja dann kein ende Mehr ist ja ein Kreis. Die Decibel sind dann hinfällig
Colour Direction Finder by DF6NM

Zu der Ortung möchte ich jetzt keine weitere Konversation eingehen.
 
Mit aufweiten meine ich die Länge des Gradient's verändern von (mal gesponnen) 5px, bis so lang das jede Farbe die im Array ist ein mal komplett in das Canvas passt.
Nee, immer noch nicht. was heißt länge des gradienten verändern, die länge deines gradienten ist ja die länge deines canvas. hast du einen gradienten von 5 px ist dein canvas 5px lang.
oder meinst du die länge eines teilgradienten? dein gradient setzt sich ja aus 3 teilgradienten zusammen.
gradient1: farbe[0] bis farbe[1]
gradient2: farbe[1] bis farbe[2]
gradient3: farbe[2] bis farbe[3]
willst du die breakpoints hier verändern? soll gradient1 noch mehr über die ersten 33% der canvaslänge wirksam sein sondern nur noch über die ersten 25% und gradient2 dann über die nächsten 50% und gradient3 dann über die letzten 25%? so?
Das max ist also 4*Canvas länge.
wie 4 mal canvas länge? du hast nur Canvas länge.

Nochmal, das Gradient wird immer mit allen Farben die im array vorkommen gerendert. auch wenn es über den Kontrastregler nur auf 5px länge eingestellt wurde.
ahh, du willst den gradient nur auf kontrasreglerwert% deiner Canvas länge abbilden und die position des startpunktes mit dem helligkeitsreglerwert festlegen?

Der Helligkeitsregler verschiebt das Gradient, wenn ein user das Gradient aber aus der Zeichenfläche herausschiebt dann kommt entweder nur schwarz oder nur weiß,
ja, klingt so als wäre das deine lösung

das wird dann auch auf den Spektrum gerendert weil irgendwo ist das Limit erreicht. Das heißt aber noch lange nicht das, dass Gradient weg ist, es ist immer noch da man sieht es bloß nicht mehr.
???

Schon klar deswegen baue ich ja die Geradengleichung ein mit Offset(Helligkeit) und Steigung(Kontrast) ein.
???

addColorStop ist keine Schrittweite?
nein, addColorStop setzt einen definierten farbwert auf einen definierten punkt der strecke. du könntest, wenn du berechnest wieviel prozent deiner gewünschten Schrittweite entspricht, jeweils für einen schritt 2 ColorStops/breakpoints mit der selben farbe einfügen, das ist aber auch irgendwie sinnlos, dann brauchst du keinen gradienten, sondern kannst das gleich als rechtecke zeichnen.

ist es nun so wie ich vermute?
 
tsseh schrieb:
ahh, du willst den gradient nur auf kontrasreglerwert% deiner Canvas länge abbilden und die position des startpunktes mit dem helligkeitsreglerwert festlegen?
Ja!!


tsseh schrieb:
ja, klingt so als wäre das deine lösung
Ja, ja, ja, ja, Ja


tsseh schrieb:
Schon klar deswegen baue ich ja die Geradengleichung ein mit Offset(Helligkeit) und Steigung(Kontrast) ein.
???
Was gab es daran nicht zu verstehen?
Der Helligkeitsregler legt fest Ab wo farbig gerendert wird z.B -120 db bis -80db sind schwarz ab -80 bis 0 wird Farbig. Oder aber er möchte -80 db nicht rot sondern gelb haben.
Das alles macht der Helligkeitsregler in meine Augen ist das ein Offset.

Der Kontrastregler stellt die Steilflankigkeit ein. Wenn alles von -120 db bis -80db schwarz ist und das Gradient nur 5px lang ist .. oder andres gesagt das Gradient umfast nur 5db dann ist alles von -120 db bis -80db schwarz -80bis -75db ist Farbig der Rest kommt weiß. Im Spektrum versteht sich.

Möchte ein User dieses 5db breite Gradient aber bei -100db haben dann muss er es auch bis zu -100db rücken können via des Helligkeitsregler's.


tsseh schrieb:
nein, addColorStop setzt einen definierten farbwert auf einen definierten punkt der strecke. du könntest, wenn du berechnest wieviel prozent deiner gewünschten Schrittweite entspricht, jeweils für einen schritt 2 ColorStops/breakpoints mit der selben farbe einfügen, das ist aber auch irgendwie sinnlos, dann brauchst du keinen gradienten, sondern kannst das gleich als rechtecke zeichnen.

ist es nun so wie ich vermute?

Das Gradient dient nur als eyecatcher ich hätte auch plump Rechtecke nehmen können wollte ich aber nicht.
Wenn du was mit Schrittweite vermutest, dann ist die Vermutung falsch.
 
Was gab es daran nicht zu verstehen?
weil du auf die aussage, du kannst nicht das spectrum mit chroma und die legende mit einem canvas gradient berechnen, sondern musst bei beiden den selben algorithmus verwenden, nicht damit antworten kannst, dass du ja genau deswegen ja im 2. algorithmus 2 regler verwendest.

Der Helligkeitsregler legt fest Ab wo farbig gerendert wird z.B -120 db bis -80db sind schwarz ab -80 bis 0 wird Farbig. Oder aber er möchte -80 db nicht rot sondern gelb haben.
Das alles macht der Helligkeitsregler in meine Augen ist das ein Offset.
kann man so sehen

Der Kontrastregler stellt die Steilflankigkeit ein. Wenn alles von -120 db bis -80db schwarz ist und das Gradient nur 5px lang ist .. oder andres gesagt das Gradient umfast nur 5db dann ist alles von -120 db bis -80db schwarz -80bis -75db ist Farbig der Rest kommt weiß.
was einen bereich festlegt den du betrachten willst

Das Gradient dient nur als eyecatcher ich hätte auch plump Rechtecke nehmen können wollte ich aber nicht.
ich meinte was anderes

Wenn du was mit Schrittweite vermutest, dann ist die Vermutung falsch.
ich meinte das was du mit ja beantwortet hast

jedenfalls must du dann nur Helligkeitsreglerwert% deiner canvaslänge berechnen und (Helligkeitsreglerwert + kontrastreglerwert)% deiner canvaslänge. die beiden werte trägst du als limits bei chroma ein.
vermutlich reicht das schon aus, da müsstest du mal nachsehen was chroma macht wenn man werte außerhalb der limits reinreicht.
begrenzt chroma die nicht selbst auf die limits müsstest du das noch machen.
der einzig kritische punkt könnte sein, wenn du den kontrastreglerwert auf 0 eingestellt hast, keine ahnung ob chroma das auch verkraftet, sollte so sein, aber wer weiß
 
tsseh schrieb:
jedenfalls must du dann nur Helligkeitsreglerwert% deiner canvaslänge berechnen und (Helligkeitsreglerwert + kontrastreglerwert)% deiner canvaslänge. die beiden werte trägst du als limits bei chroma ein.
vermutlich reicht das schon aus, da müsstest du mal nachsehen was chroma macht wenn man werte außerhalb der limits reinreicht.
begrenzt chroma die nicht selbst auf die limits müsstest du das noch machen.
der einzig kritische punkt könnte sein, wenn du den kontrastreglerwert auf 0 eingestellt hast, keine ahnung ob chroma das auch verkraftet, sollte so sein, aber wer weiß


Ok, ich gebe das mal ein.

mikdoe schrieb:
Hallo micha, ich finde das überhaupt nicht amüsant. Hesst hat sich dermaßen mit der Schrittweite verbissen, der weilen habe ich nie was von Schrittweite erwähnt.
Wir 2 sind wie so Magneten die gegeneinander abstoßen und davon noch Die stärksten Magneten sprich, Neodym.

Ich arbeite seit über 7 Jahren im Hausanschlusswesen. Das heißt ich Plane, realisiere und rechne ab, alle Medien die so in ein Haus rein gehen.
Im Jahr komme wir auf so c.a. ~600 Hausanschlüsse.
Das wider rum bedeutet ich rede im Jahr mit 600 Kunden/Bauherren und erkläre wie Teuer wird es wie läuft das ab usw.

Bis jetzt habe ich mich mit jeden Bauherren(in) verstanden.. aber mit Hesst komme ich auf keinen gemeinsamen Nenner.

Man sagt ja immer zwei von der selben Sorte verstehen sich nicht. Ob das wirklich so ist lässt sich nur zusamen bei einen Bierchen herausfinden, Problem dabei ich trinke kein Bier noch nicht mal Alkohol. Wenn Hesst jetzt auch keines trinkt ja dann sind wir von der selben Sorte.;)

Ende dieser Konversation.

30,73,88!!
 
Zuletzt bearbeitet:
Hesst hat sich dermaßen mit der Schrittweite verbissen, der weilen habe ich nie was von Schrittweite erwähnt.
nee, ich habe mich nicht verbissen, du kanns nur deine probleme nicht beschreiben
das
1% ist ganz klein nur ein Farbklecks so zusagen und 100% wäre jede Farbe die im Array vorkommt passt einmal komplett in die Canvas width.
ist die beschreibung einer schrittweite, bzw anzahl vorkommender farben, was das gleiche ist
 
tsseh schrieb:
ist die beschreibung einer schrittweite, bzw anzahl vorkommender farben, was das gleiche ist
Warm denn nur? Die anzahl der Farben im Gradient sind immer die selben nur das sich die Gradient länge auf ein Prozentwert der Canvaslänge geregelt wird.


Schau mal das entspricht jetzt meinen Anforderungen.
Code:
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/html">

<head>
    <title>colorsclaehelper</title>
    <script src=chroma.js></script>
    <script type="text/javascript">
        var csh;
    function ready(){
        
function colorScaleHelper(ColorScalHelper_ClassID) {
    var canvas = document.getElementById(ColorScalHelper_ClassID);
    this.canvas_width = canvas.width;
    this.canvas_height = canvas.height;
    this.canvas_ctx = canvas.getContext("2d");
    this.canvas_ctx.imageSmoothingEnabled = false;
    this.colors = ['#000000', '#ff0000', '#ffff00', '#ffffff'];
    this.db_from = -120;
    this.db_to = 0;
    this.contrast = 50;
    this.brightness = 50;
    this.renderdBscale();
    this.renderColorScale();
}


colorScaleHelper.prototype.setdB = function(db_from, db_to) {
 this.db_from = db_from;
 this.db_to = db_to;
};

colorScaleHelper.prototype.setColors = function(colors) {
    this.colors = colors;
    this.renderColorScale();
};

colorScaleHelper.prototype.setBrigthness = function(bright) {
    this.brightness = bright*-1;
    console.log(bright)
    this.renderColorScale();
};

colorScaleHelper.prototype.setContrast = function(con) {
    this.contrast = con*-1;
    this.renderColorScale();
};

colorScaleHelper.prototype.renderColorScale = function() {
    this.canvas_ctx.clearRect(0, 0, this.canvas_width, this.canvas_height - 25);
     var grdWidth =  this.contrast*(this.canvas_width*this.colors.length)/100;
    var xoffs =   grdWidth  * (-1 + 2* this.brightness / 100);
    var firstColor = this.colors[0];
    
    var grd =  this.canvas_ctx.createLinearGradient(xoffs,0,grdWidth+xoffs,0);
    for (var i = 0; i < this.colors.length; i++) {
        var xcolorSpan = i*1.0/this.colors.length;
        grd.addColorStop(xcolorSpan, this.colors[i]);
    }
    
     this.canvas_ctx.fillStyle = grd;
    this.canvas_ctx.fillRect(0, 0,  this.canvas_width, this.canvas_height - 25);

};

colorScaleHelper.prototype.renderdBscale = function() {

    var width = this.canvas_width;
    var beginn = 30;
     this.canvas_ctx.clearRect(0,  beginn, this.canvas_width,25);
     this.canvas_ctx.fillStyle = "white";
     this.canvas_ctx.fillRect(0,  beginn, this.canvas_width, 25);
     this.canvas_ctx.strokeStyle = "black";
     this.canvas_ctx.font = "12px Calibri";
     this.canvas_ctx.fillStyle = "black";
    var ticks = 25;
    var dBs = this.db_from - this.db_to;
    var xSpan = this.canvas_width / ticks;
    var steps = dBs / ticks;
    if (steps < 0) steps *= -1;
    var exp = Math.floor(Math.log(steps) / Math.LN10);
    var stepnorm = steps / Math.pow(10, exp);
    var schritt = Math.ceil(stepnorm * Math.pow(10, exp));
    var Numr = this.db_from;
    if (this.db_from < 0) Numr *= -1;
    for (var i = 0; i < ticks; i++, Numr -= schritt) {
        if (this.db_from < 0) {
            var string = Math.round(-Numr) + "";
        } else {
            var string = Math.round(Numr) + "";
        }
        var x = i * xSpan;
        if ((i % 2) == 0) {
             this.canvas_ctx.moveTo(x,  beginn);
             this.canvas_ctx.lineTo(x,  beginn+8);

        } else {
             this.canvas_ctx.moveTo(x,  beginn);
             this.canvas_ctx.lineTo(x,  beginn+6);
        }
        if (i == 5) {
             this.canvas_ctx.moveTo(x,  beginn);
             this.canvas_ctx.lineTo(x,  beginn+12);
             this.canvas_ctx.fillText(string, x - string.length * 4,  beginn+12 + 9);
        }
        if (i == 14) {
             this.canvas_ctx.moveTo(x,  beginn);
             this.canvas_ctx.lineTo(x,  beginn+12);
             this.canvas_ctx.fillText(string, x - string.length * 4,  beginn+12 + 9);
        }
        if (i == 24) {
             this.canvas_ctx.moveTo(x,  beginn);
             this.canvas_ctx.lineTo(x,  beginn+12);
             this.canvas_ctx.fillText(string, x - string.length * 4,  beginn+12 + 9);
        }


    }
    this.canvas_ctx.lineWidth = 1;
     this.canvas_ctx.stroke();
};
csh = new colorScaleHelper("canvas");
    }


    </script>
</head>

<body onload="ready()">
    <p><input type="range" min="-100" max="0" step="1" onchange="csh.setBrigthness(this.value)" />Brightness</p>
     <p><input type="range" min="-100" max="0" step="1" onchange="csh.setContrast(this.value)" />Contrast</p>
    <p><canvas style="background-color: grey;" id="canvas" width="150" height="55"></canvas></p>

</body>

</html>
Nur gibt es ein kleines Problem, wenn der Helligkeitsregler auf 50% steht muss immer die Mitte des Gradientes in der Mitte des Canvas stehen, tut es aber nicht.
Unabhängig davon wie lang das Gradient gerade ist.
Und nein ich möchte das Gradient nicht über ChromaJs gerendert haben!
 
Schau mal das entspricht jetzt meinen Anforderungen.
das hat aber nichts mit dem zu tun was ich gesagt habe

Nur gibt es ein kleines Problem, wenn der Helligkeitsregler auf 50% steht muss immer die Mitte des Gradientes in der Mitte des Canvas stehen, tut es aber nicht.
bei dem was ich vermutet habe beginnt der gradient in der mitte des Canvas wenn der Helligkeitsregler auf 50% steht.
soll aber nicht so sein?

Und nein ich möchte das Gradient nicht über ChromaJs gerendert haben!
doch das möchtest du
 
tsseh schrieb:
das hat aber nichts mit dem zu tun was ich gesagt habe
ja weil du wider auf den ChromaJs Zug aufgesprungen bist und da fahre ich nicht mit.

tsseh schrieb:
bei dem was ich vermutet habe beginnt der gradient in der mitte des Canvas wenn der Helligkeitsregler auf 50% steht.
soll aber nicht so sein?

50% ist Gradient Mitte, immer egal wie lang das Gradient gerade ist. 100% soll komplet schwarz sein , 0% soll komplett weiß sein.

tsseh schrieb:
doch das möchtest du
Nein Möchte ich nicht. Wenn ich Pommes mit majonäse bestelle kannst du mir nicht Pommes mit Ketschup geben.
 
ja weil du wider auf den ChromaJs Zug aufgesprungen bist
das ist mit einem canvas gradient nicht viel anders(auf die regler bezogen)

da fahre ich nicht mit.
deine entscheidung

50% ist Gradient Mitte, immer egal wie lang das Gradient gerade ist. 100% soll komplet schwarz sein , 0% soll komplett weiß sein.
das ist keine beschreibung
soll der kontrastregler festlegen wo sich die mitte des gradienten besinden soll? das wäre nicht viel anders als würdest du den startpunkt festlegen.
dann ist bei 0 und 100 aber nicht nur eine farbe vorhanden.

Nein Möchte ich nicht.
doch, möchtest du
 
Zurück
Oben