// --- VARIABILE GLOBALE ---
JSONArray lumini;
float[] deschideri, maxime, minime, închideri, volume;
float pretActual, ATH , LOW= 0;
String ech = "1m";
ArrayList clustereLichidare = new ArrayList();
ArrayList numărClustere = new ArrayList();
//ArrayList suporturi = new ArrayList();
ArrayList suportSparte = new ArrayList();
int aleator= 0;
ArrayList suporturi = new ArrayList();
ArrayList spargeriSuport = new ArrayList();
String simbol = "BTCUSDT";
int numărSimbol=1;
String[] simboluri = {
"BTCUSDT", "PAXGUSDT","BTCUSDC","TRUMPUSDC","ANIMEUSDC", "CAKEUSDC", "VIRTUALUSDC", "SAHARAUSDC","CUSDC","FUSDC", "PEPEUSDT","ETHUSDT", "BNBUSDT", "SOLUSDT", "XRPUSDT", "DOGEUSDT", "ADAUSDT", "AVAXUSDT", "AUCTIONUSD", "DOTUSDT",
„TRXUSDT”, „LTCUSDT”, „LINKUSDT”, „BCHUSDT”, „ATOMUSDT”, „XLMUSDT”, „HMSTRUSD”, „UNIUSDT”, „ETCUSDT”, „FILUSDT”, „ICPUSDT”,
„HBARUSDT”, „APTUSDT”, „IMXUSDT”, „ARBUSDT”, „NEARUSDT”, „OPUSDT”, „GRTUSDT”, „VETUSDT”, „EGLDUSDT”, „SANDUSDT”,
„AXSUSDT”, „MANAUSDT”, „STXUSDT”, „XTZUSDT”, „THETAUSDT”, „RNDRUSDT”, „AAVEUSDT”, „KAVAUSDT”, „ALGOUSDT”, „DYDXUSDT”,
„TUSDT”, „CROUSDT”, „FTMUSDT”, „GALAUSDT”, „CHZUSDT”, „ENJUSDT”, „ONEUSDT”, „RUNEUSDT”, „ZILUSDT”, „LRCUSDT”,
„FLOWUSDT”, „ROSEUSDT”, „CRVUSDT”, „ENSUSDT”, „ZRXUSDT”, „BATUSDT”, „KSMUSDT”, „COMPUSDT”, „WAVESUSDT”, „1INCHUSDT”,
„BALUSDT”, „SUSHIUSDT”, „XEMUSDT”, „YFIUSDT”, „BNTUSDT”, „SKLUSDT”, „OCEANUSDT”, „ANKRUSDT”, „CELOUSDT”, „GLMRUSDT”,
„SRMUSDT”, „MOVRUSDT”, „CTSIUSDT”, „REEFUSDT”, „CVCUSDT”, „BANDUSDT”, „LITUSDT”, „API3USDT”, „ALICEUSDT”, „RLCUSDT”,
„KNCUSDT”, „STORJUSDT”, „NKNUSDT”, „DENTUSDT”, „POWRUSDT”, „RENUSDT”, „ARPAUSDT”, „VTHOUSDT”, „TRBUSDT”, „IDEXUSDT”,
„FORTHUSDT”, „MTLUSDT”, „PERLUSDT”, „SYSUSDT”, „TLMUSDT”, „UFTUSDT”, „XNOUSDT”, „XVGUSDT”, „ELAUSDT”, „BICOUSDT”
};
rezistențe ArrayList = new ArrayList();
float fundingRates[] ;//= fetchFundingRates(symbol, 1000); // ultimele 1000 de rate de finanțare
float[] fetchFundingRates(symbol string, int limit) {
float[] rate = new float[limită];
URL-ul șirului = "https://fapi.binance.com/fapi/v1/fundingRate?symbol=" + symbol + "&limit=" + limit;
încercați {
Șir de caractere brut = join(loadStrings(url), "");
JSONArray arr = parseJSONArray(raw);
println("nume finanțare:" + arr.size());
pentru (int i = 0; i < arr.size(); i++) {
JSONObject obj = arr.getJSONObject(i);
rates[i] = float(obj.getString("fundingRate"));
dacă (rates[i] < 0) println("detectată");
}
} catch(Excepție e) {
println("Eroare la fetchFundingRates: " + e);
}
rate de returnare;
}
// --- PARAMETRI (cum ar fi intrările tale Pine) ---
int volum_retrospectiv = 50;
float volMult = 2.5;
Raportul fitilului plutitor = 0,6f;
float RaportCorp minim = 0.1f;
float proximityPts = 20f; // toleranță pentru gruparea clusterelor
int pivotStânga = 5;
int pivotDreapta = 5;
interval întreg = 1000; // 1000 ms = 1 secundă
int ultimaActualizare = 0;
lățimi întregi;
// --- Calcul EMA ---
float[] ema(float[] date, int punct) {
float[] ema = new float[data.length];
număr cu număr mobil alfa = 2.0 / (punct + 1.0);
// Inițializare: începem cu prima valoare brută
ema[0] = date[0];
pentru (int i = 1; i < date.length; i++) {
ema[i] = alpha * data[i] + (1 - alpha) * ema[i-1];
}
returnează ema;
}
// --- ÎNFIINȚAT ---
setup() void {
//dimensiune(1200, 800);
ecran complet();
//size(int(displayWidth*2),int(displayHeight));
simbol = simboluri[numărSimbol];
fetchData(simbol);
lățimi = int(lățime * 8.7); // 8.1
fundingRates = fetchFundingRates(symbol, 1000); // Ultimele 1000 de rate de finanțare
//rataframe(1);
// Schimbați simbolul dacă doriți
}
float startDist;
zoom în flotor = 1.0;
float offsetX = 0;
float offsetY = 0;
void atingereÎnceput() {
dacă (atinge.lungime == 2) {
startDist = dist(atingeri[0].x, atingeri[0].y, atingeri[1].x, atingeri[1].y);
}
}
void atingereMutat() {
dacă (atinge.lungime == 2) {
float newDist = dist(atingeri[0].x, atingeri[0].y, atingeri[1].x, atingeri[1].y);
float d = newDist / startDist;
mărire *= d;
zoom = constrain(zoom, 0.1, 10); // limite zoom
startDist = newDist;
} altfel dacă (atinge.lungime == 1) {
offsetX += (atinge[0].x - pmouseX) / zoom;
offsetY += (atingeri[0].y - pmouseY) / zoom;
}
}
// Trageți cu mouse-ul (util pentru testare pe PC)
void mouseTras() {
offsetX += (mouseX - pmouseX) / zoom;
offsetY += (mouseY - pmouseY) / zoom;
dacă ( mouseX < lățime && mouseX > lățime-100 && mouseY > înălțime-200 && mouseY < înălțime-100){
++gapMin;
}
dacă ( mouseX < lățime && mouseX > lățime-100 && mouseY > înălțime-100 && mouseY < înălțime){
--gapMin;
}
}
void mousePressed()
{
//++numărSimbol;
//umplere(255);
//rect(lățime-200, 100,200,200);
dacă (mouseX > lățime-200 && mouseY < 300 && mouseY > 100)
++numărSymbol;
dacă (mouseX > lățime-200 && mouseY < 500 && mouseY > 300)
--numărSimbol;
dacă (numărSimbol<0)
SimbolNumărător = 0;
dacă (numărSimbol>101)
SimbolNumărător = 0;
//text(simboluri[numărSimbol],lățime-150,150);
simbol = simboluri[numărSimbol];
}
void mouseReleased()
{
dacă ( mouseX < lățime && mouseX > lățime-100 && mouseY > înălțime-200 && mouseY < înălțime-100){
++gapMin;
}
dacă ( mouseX < lățime && mouseX > lățime-100 && mouseY > înălțime-100 && mouseY < înălțime){
--gapMin;
}
}
float rsi(int i, float[] se închide, int punct) {
dacă (i < punct) returnează 50; // implicit dacă nu sunt suficiente date
câștigul în plutitor = 0, pierderea = 0;
pentru (int j = 1; j <= punct; j++) {
modificare float = închide[i - j + 1] - închide[i - j];
dacă (modificare > 0) câștig += modificare;
altfel pierdere -= schimbare;
}
float avgGain = câștig / perioadă;
float avgLoss = pierdere / perioadă;
dacă (avgLoss == 0) returnează 100; // RSI maxim dacă nu există pierderi
float rs = câștig mediu / pierdere medie;
returnează 100 - (100 / (1 + rs));
}
int n = 30; // dimensiunea ferestrei
toleranță float = 100.5; // margine pentru a indica „atinge plafonul”
void detectResistance(int i, float[] maxime, float[] închide) {
dacă (i < n) returnează; // nu sunt încă suficiente date
// Luăm valoarea maximă pentru ultimele n lumânări
float maxRecent = valori maxime[i];
pentru (int j = 1; j < n; j++) {
dacă (maxime[i - j] > maxRecent) {
maxRecent = maxime[i - j];
}
}
// Numărăm de câte ori prețul a „atins” aproape maximul
int atingeri = 0;
pentru (int j = 0; j < n; j++) {
dacă (abs(înalte valori[i - j] - maxRecent) < toleranță) {
atinge++;
}
}
// Calculul RSI nu va fi afișat
// vinde la prețul cel mai mic
valoare rsi cu float = rsi(i, închide, 27);
// Dacă atinge des, dar nu depășește 100°C, semnalizează
dacă (touchs > 2 && closes[i] < maxime[i] - toleranță && rsiValue > 60) {
float xp = map(i, 0, closes.length - 1, 50, widths - 50);
float y = map(highs[i], min(closes), max(closes), height - 50, 50);
umplere(255, 255, 0, 150);
fărăAccident();
rect(xp, y, 30, 15);
//umplere(255);
textAlign(CENTRU);
text("SCURT ×100", xp, y - 10);
}
}
// --- DESENARE BUCLA ---
void draw() {
aleatoriu =0;
dacă (millis() - ultimaActualizare >= interval) {
//fetchData(symbol); // Reîmprospătăm datele
/*closes = new float[666]; // resetează tabloul closures
supports.clear(); // Ștergem lista de suporturi
supportBreaks.clear(); // șterge lista de pauze
liquidationClusters.clear(); // se afișează clusterele de lichidare
clusterCounts.clear();
supportBroken.clear();*/
simbol = simboluri[numărSimbol];
fetchData(simbol);
lastUpdate = millis(); // Resetăm contorul la zero
}
pushMatrix();
translate(lățime/2 + offsetX*zoom, înălțime/2 + offsetY*zoom-400);
//traducere(lățime/2 + offsetX, înălțime/2 + offsetY-400);
scalare(zoom);
//fetchData("BTCUSDT");
fundal(20);
accident vascular cerebral (255);
umplere(200);
// limite verticale pentru scalare
float maxP = max(închide);;
float minP = min(închide);
/*
pentru (int i = 0; i < închide.length; i+=10) {
float xpr = map(i, 0, closes.length - 1, 50, widths-50);
float y = map(valoareminime[i], Pmin, Pmax, înălțime - 50, 50);
umplere(255, 25, 255, 150);
fărăAccident();
rect(xpr-20, y - 40,40,40);
}
pentru (int i = 5; i < închide.length; i+=10) {
float xpr = map(i, 0, closes.length - 1, 50, widths-50);
float y = map(valoareminime[i], Pmin, Pmax, înălțime - 50, 50);
umplere(25, 255, 255, 150);
fărăAccident();
rect(xpr-20, y - 40,40,40);
}
*/
// --- URMĂTORUL ---
accident vascular cerebral (255, 255, 0);
float yATH = map(ATH, minP, maxP, înălțime - 50, 50);
linie(50, yATH, lățimi-50, yATH);
umplere(255, 255, 0);
text("ATH " + ATH, 55, yATH-5);
fill(255,0,0,55);rect(50,yATH,lățimi,100);
// --- URMĂTORUL ---
accident vascular cerebral (25, 255, 255);
yATH = map(LOW, minP, maxP, height-50, 50);
linie(50, yATH, lățimi-50, yATH);
umplere(255, 255, 0);
text("SCĂZUT " + SCĂZUT, 55, yATH-5);
fill(0,255,0,55);rect(50,yATH,lățimi,-100);
// Graficul prețului (grafic cu linii închise)
/*
pentru (int i=1; i
float x1 = map(i-1, 0, closes.length, 50, width-50);
float y1 = map(closes[i-1], minP, maxP, height-50, 50);
float x2 = map(i, 0, closes.length, 50, width-50);
float y2 = map(closes[i], minP, maxP, height-50, 50);
accident vascular cerebral (180);
Greutate_cursă(2);
linie(x1, y1, x2, y2);
deschide = un număr float nou[n];
maxime = valoare float nouă[n];
minime = valoare float nouă[n];
închide = new float[n];
}*/
Greutate cursă(1.3);
umplere(223,12);
începeShape();
pentru (int i = 0; i < închide.length; i++) {
float x = map(i, 0, closes.length - 1, 50, widths-50);
float y = map(closes[i], minP, maxP, height - 50, 50);
vârf(x, y);
// comenzi limită
}
endShape();
fărăAccident();
float[] ema3 = ema(se închide, 666);//18
Greutate_cursă(3);
fără umplere();
pentru (int i = 1; i < ema3.length; i++) {
float x1 = map(i-1, 0, closes.length-1, 50, widths-50);
valoare float y1 = map(ema3[i-1], minP, maxP, height-50, 50);
float x2 = map(i, 0, closes.length-1, 50, widths-50);
valoare float y2 = map(ema3[i], minP, maxP, height-50, 50);
dacă (ema3[i] > ema3[i-1]) {
stroke(0, 255, 0); // vertical dacă este în sus
} altfel {
stroke(255, 0, 0); // roșu și coborâre
}
linie(x1, y1, x2, y2);
}
ema3 = ema(închide, 18); //18
Greutate_cursă(3);
fără umplere();
pentru (int i = 1; i < ema3.length; i++) {
float x1 = map(i-1, 0, closes.length-1, 50, widths-50);
valoare float y1 = map(ema3[i-1], minP, maxP, height-50, 50);
float x2 = map(i, 0, closes.length-1, 50, widths-50);
valoare float y2 = map(ema3[i], minP, maxP, height-50, 50);
dacă (ema3[i] > ema3[i-1]) {
stroke(0, 255, 0); // vertical dacă este în sus
} altfel {
stroke(255, 0, 0); // roșu și coborâre
}
linie(x1, y1, x2, y2);
}
/*
// lățimea fiecărei lumânări + spațiu
lumânare flotantă W = 5;
float spacing = 2; // spațiu între lumânări
diagramă cu floatLățime = (lțimea lumânării + spațiere) * închide.lungime;
pentru (int i = 0; i < închide.length; i++) {
// X cu spațiere regulată
float x = 50 + i * (candelW + spațiere);
// maparea Y
float yo = map(se deschide[i], minP, maxP, înălțime - 50, 50);
float yc = map(closes[i], minP, maxP, înălțime - 50, 50);
float yh = map(înălțimi[i], minP, maxP, înălțime - 50, 50);
float yl = map(înălțime minimă[i], P minim, P maxim, înălțime - 50, 50);
// --- Wick ---
accident vascular cerebral (200);
linie(x, yh, x, yl);
// --- Corpul ---
dacă (închide[i] >= deschide[i]) {
umplere(0, 200, 0);
accident vascular cerebral(0, 200, 0);
rect(x - lumânareW/2, yc, lumânareW, yo - yc);
} altfel {
umplere(200, 0, 0);
accident vascular cerebral(200, 0, 0);
rect(x - lumânareW/2, yo, lumânareW, yc - yo);
}
}
*/
pentru (int i = 0; i < închide.length; i++) {
float x = map(i, 0, closes.length - 1, 50, widths-50);
// maparea Y
float yo = map(se deschide[i], minP, maxP, înălțime - 50, 50);
float yc = map(closes[i], minP, maxP, înălțime - 50, 50);
float yh = map(înălțimi[i], minP, maxP, înălțime - 50, 50);
float yl = map(înălțime minimă[i], P minim, P maxim, înălțime - 50, 50);
// lățimea unei lumânări
lumânare flotantăW = 4,5;
// --- Wick ---
dacă (închide[i] >= deschide[i])
// Lumânare verde
accident vascular cerebral(0,200,0);
altceva
accident vascular cerebral(200,0,0);
Greutate cursă(1.3);
linie(x, yh, x, yl);
fărăAccident();
// --- Corpul ---
dacă (închide[i] >= deschide[i]) {
// Lumânare verde
umplere(0, 200, 0);
accident vascular cerebral(0, 200, 0);
rect(x - lumânareW/2, yc, lumânareW, yo - yc);
} altfel {
// Lumânare roșie
umplere(200, 0, 0);
accident vascular cerebral(200, 0, 0);
rect(x - lumânareW/2, yo, lumânareW, yc - yo);
}
boolean baseHistorique = true;
dacă (i > 84)
pentru (int j = 0; j < 83; j++) {
dacă (minime[i-j-1] < minime[i]) {
basHistorique = fals;
pauză;
}
}
altfel baseHistorique = fals;
dacă (downHistory)
{
//dacă (rsiC>10 && rsiC < 50-Indicator && basHistorique){
//dacă (rsiC < 45 && basHistorique){
//dacă (rsiC < 35 && basHistorique){// && date[i]< prixHaut-20)
// Poziționează punctul
float xp = map(i, 0, closes.length - 1, 50, widths-50);
float y = map(valoareminime[i], Pmin, Pmax, înălțime - 50, 50);
umplere(255, 0, 0,150);
fărăAccident();
rect(xp-20, y - 40,40,40);
//elipsă(xp-5, y, 10, 10);
umplere(0, 255, 0);
textAlign(CENTRU);
//rect(x - decX, y - 8,10,10);
///bas[i]=1;
dacă (minime[i] < minime[i-83])
text("LL", xp, y - 10);
altceva
text("HL", xp, y - 10);
// bază[i]=1;
// la o cumpărare nereușită
//CONFIRMAȚI= adevărat;
}
boolean HautHistorique = true;
dacă (i > 84)
pentru (int j = 0; j < 83; j++) {
dacă (înalte valori[i-j-1] > înalte valori[i]) {
HautHistorique = fals;
pauză;
}
}
altfel HautHistorique = fals;
dacă (HautHistorique)
{
//dacă (rsiC>10 && rsiC < 50-Indicator && basHistorique){
//dacă (rsiC < 45 && basHistorique){
//dacă (rsiC < 35 && basHistorique){// && date[i]< prixHaut-20)
// Poziționează punctul
float xp = map(i, 0, closes.length - 1, 50, widths-50);
float y = map(înălțimi[i], minP, maxP, înălțime - 50, 50);
umplere(255, 255, 0,150);
fărăAccident();
rect(xp-20, y - 40,40,40);
//elipsă(xp-5, y, 10, 10);
umplere(0, 255, 255);
textAlign(CENTRU);
//rect(x - decX, y - 8,10,10);
///bas[i]=1;
dacă ( maxime[i] > maxime[i-83])
text("HH", xp, y - 10);
altceva
text("Hl", xp, y - 10);
// bază[i]=1;
dacă (i<990)
{
float xi = map(i+9, 0, closes.length - 1, 50, widths-50);
float yi = map(înălțimi[i+9], minP, maxP, înălțime - 50, 50);
accident vascular cerebral (255, 255, 0);
linie(xp, y, xi,yi);
}
// la o cumpărare nereușită
//CONFIRMAȚI= adevărat;
}
///////////// vârfurile mici
bazăIstorică = adevărat;
dacă (i > 9)
pentru (int j = 0; j < 8; j++) {
dacă (minime[i-j-1] < minime[i]) {
basHistorique = fals;
pauză;
}
}
altfel baseHistorique = fals;
dacă (downHistory)
{
//dacă (rsiC>10 && rsiC < 50-Indicator && basHistorique){
//dacă (rsiC < 45 && basHistorique){
//dacă (rsiC < 35 && basHistorique){// && date[i]< prixHaut-20)
// Poziționează punctul
float xp = map(i, 0, closes.length - 1, 50, widths-50);
float y = map(valoareminime[i], Pmin, Pmax, înălțime - 50, 50);
umplere(255, 0, 0,150);
fărăAccident();
//rect(xp-20, y - 40,40,40);
elipsă(xp-5, y, 10, 10);
umplere(0, 255, 0);
textAlign(CENTRU);
//rect(x - decX, y - 8,10,10);
///bas[i]=1;
// dacă ( lows[i] < lows[i-83])
//text("LL", xp, y - 10);
//altfel
//text("HL", xp, y - 10);
// bază[i]=1;
// la o cumpărare nereușită
//CONFIRMAȚI= adevărat;
}
TopHistorical = true;
dacă (i > 9)
pentru (int j = 0; j < 8; j++) {
dacă (înalte valori[i-j-1] > înalte valori[i]) {
HautHistorique = fals;
pauză;
}
}
altfel HautHistorique = fals;
dacă (HautHistorique)
{
//dacă (rsiC>10 && rsiC < 50-Indicator && basHistorique){
//dacă (rsiC < 45 && basHistorique){
//dacă (rsiC < 35 && basHistorique){// && date[i]< prixHaut-20)
// Poziționează punctul
float xp = map(i, 0, closes.length - 1, 50, widths-50);
float y = map(înălțimi[i], minP, maxP, înălțime - 50, 50);
umplere(255, 255, 0,150);
fărăAccident();
//rect(xp-20, y - 40,40,40);
elipsă(xp-5, y, 10, 10);
umplere(0, 255, 255);
textAlign(CENTRU);
//rect(x - decX, y - 8,10,10);
///bas[i]=1;
dacă ( maxime[i] > maxime[i-7])
text("HH", xp, y - 10);
altceva
text("Hl", xp, y - 10);
// bază[i]=1;
/*dacă (i<990)
{
float xi = map(i+9, 0, closes.length - 1, 50, widths-50);
float yi = map(înălțimi[i+9], minP, maxP, înălțime - 50, 50);
accident vascular cerebral (255, 255, 0);
linie(xp, y, xi,yi);
}*/
// la o cumpărare nereușită
//CONFIRMAȚI= adevărat;
}
// Rezistența atunci când prețul nu crește
detectResistance(i, maxime, închideri);
}
/*
pentru (int i = 0; i < închide.length; i++) {
float x = map(i, 0, closes.length - 1, 50, width - 50);
//valoare variabilă y = map(closes[i], minP, maxP, înălțime - 50, 50);
float yh = map(înălțimi[i], minP, maxP, înălțime - 50, 50);
float yl = map(înălțime minimă[i], P minim, P maxim, înălțime - 50, 50);
umplere(0,255,0,123);
rect(x-10, yh,10, yh-il);
//se deschide = new float[n];
//maxime = new float[n];
//minime = new float[n];
//închide = new float[n];
// comenzi limită
}
accident vascular cerebral(0,0,255);
accident vascular cerebral (25, 255, 255);
*/
Greutate_cursă(2);
// --- Grupuri de lichidare ---
accident vascular cerebral(255, 0, 0);
pentru (int i=0; i
nivel float = liquidationClusters.get(i);
float y = map(lvl, minP, maxP, height-50, 50);
linie(50, y, lățimi - 50, y);
umplere(255, 0, 0);
text("LC x" + clusterCounts.get(i), lățimi-100, y-5);
}
/*
// --- Susține și pauze ---
pentru (int i=0; i
nivel float = supports.get(i);
float y = map(lvl, minP, maxP, height-50, 50);
dacă (supportBroken.get(i)) {
contur(25, 50, 255); // pauză = portocaliu
} altfel {
contur(0, 200, 255); // suport = vertical
}
linie(50, y, lățime-50, y);
}*/
// --- Hartă termică a clusterelor ---
//deseneazăClusters(minP, maxP);
// --- Hartă termică a clusterelor ---
drawClusters(minP, maxP);
// --- Suportă (zone verzi) ---
drawSupports(minP, maxP);
// --- Pauze (zone portocalii groase) ---
drawBreaks(minP, maxP);
//detectarerezistențe();
//deseneazăSemnale(minP, maxP);
//deseneazăClusters(prețmin, prețmax);
drawTradeRectangles(închideri, maxime, minime, minP, maxP);
drawFVG(minP, maxP);
/*
int frIndex = fundingRates.length - 1; // pe ultima rată de finanțare
// Parcurgem lumânările începând de la sfârșit
pentru (int i = închide.length - 1; i >= 0 && frIndex >= 0; i -= 8) {
dacă (fundingRates[frIndex] < 0) {
float x = map(i, 0, closes.length - 1, 50, widths - 50);
fill(255, 255, 0, 70); // galben
rect(x-5, 0, 10, height); // bară galbenă pe lumânarea corespunzătoare
}
frIndex--; // avansăm în tabelul de finanțare
}
*/
dacă (i == "1h")
///// semnul viermelui... scuze, pantalonii scurți... xP
pentru (int i = 0; i < fundingRates.length; ++i) {
//pentru (int i = rateDeFundare.length; i < 1 ; --i) {
//int IndexLumânare = i * 8; // si ech = 1h
dacă (rateDeFinanțare[i] < 0) {
// Putem recupera doar 1000 de franci
// valoare float x = map(i*8, 0, fundingRates.length-1, 50, widths-50);
float x = map(i*8-600, 0, closes.length-1, 50, (widths-50));
valoare float y = înălțime/2;
fill(255, 255, 0, 70); // galben
//rect(x-5, y-5, 10, 10); // pătrat mic
rect(x-5, 0, 10, height); // mic carré
dimensiunetext(33);
umplere(255);
text("SCURT", x-5,150);
}
}
dimensiunetext(12);
popMatrix();
String[] etichete = {"1s", "1m", "3m", "15m","1day","1h","2h"}; // textul intervalelor
int wld=0;
pentru (int i=0;i
{ fill(i*10,255-i*10,i);
rect(i, 0, 100, 100);
umplere(0,0,0);
text( etichete[wld % etichete.lungime], 40+i,50);
++wld;
}
umplere(255,255,255);
text(eu, 20, 130);
dacă (mouseX < 100 && mouseY < 100) {
i = "1s"; fetchData(simbol);
}
dacă (mouseX < 200 && mouseX > 100 && mouseY < 100){
i = "1m"; fetchData(simbol);
}
dacă (mouseX < 300 && mouseX > 200 && mouseY < 100) {
i = "3m"; fetchData(simbol);
}
dacă (mouseX < 400 && mouseX > 300 && mouseY < 100){
i = „15m”;
fetchData(simbol);
}
dacă (mouseX < 500 && mouseX > 400 && mouseY < 100){
i = "1d";
fetchData(simbol);
}
dacă (mouseX < 600 && mouseX > 500 && mouseY < 100){
i = "1 oră";
fetchData(simbol);
}
dacă (mouseX < 700 && mouseX > 600 && mouseY < 100){
ech = "2h";
fetchData(simbol);
}
dacă (mouseX < 900 && mouseX > 670 && mouseY < 100) {
i = „30m”;
atrageData(simbol);
}
//rect(lățime-100,înălțime-200,100,100);
//rect(lățime-100,înălțime-100,100,100);
//rect(lățime-200,0,lățime,300);
text(simboluri[numărSimbol],lățime-150,150);
// dimensiunetext(30);
//completare(t13?0:255,t13?255:0,0);
text ("PRIX :" + nf(închide[999],0,2),10,înălțime-220);
rect(lățime-100,înălțime-200,100,100);
rect(lățime-100,înălțime-100,100,100);
text (gapMin, lățime-30, înălțime-250);
}
// --- PRELUARE DATE ---
void fetchData(simbol Șir de caractere) {
//închide = new float[666];//[666]; // r�������������inițializează tabelul de închideri
supports.clear(); // Ștergem lista de suporturi
supportBreaks.clear(); // șterge lista de pauze
liquidationClusters.clear(); // se afișează clusterele de lichidare
clusterCounts.clear();
suportBroken.clear();
String URL = "https://api.binance.com/api/v3/klines?symbol=" + simbol + "&interval="+ech+"&limit=2500";
încercați {
Șir de caractere brut = join(loadStrings(url), "");
lumânări = parseJSONArray(raw);
int n = lumânări.size();
println("lumânare = "+ n);
deschide = un număr float nou[n];
maxime = valoare float nouă[n];
minime = valoare float nouă[n];
închide = new float[n];
volume = new float[n];
pentru (int i = 0; i < n; i++) {
JSONArray c = lumânări.getJSONArray(i);
deschide[i] = float(c.getString(1));
valori maxime[i] = float(c.getString(2));
valorile minime[i] = float(c.getString(3));
închide[i] = float(c.getString(4));
volumes[i] = float(c.getString(5));
// Exemplu simplificat de detectare
dacă (suportă.size() > 0) {
float lastClose = închide[i];
float prevClose = închide[i-1];
pentru (int s = supports.size()-1; s >= 0; s--) {
float preț = supports.get(s);
// Condiție de întrerupere: treceri închise sub suport
dacă (prevClose >= target && lastClose < target) {
supportBreaks.add(preț);
}
}
}
}
prețActual = închide[n-1];
ATH = max(închide);
LOW= min(închide);
detectareaClusterelor();
detectați suporturi();
detectareaClusterelorȘiFVG(gapMin);
} catch (Excepție e) {
println("Eroare API: " + e.getMessage());
}
}
diferență de valoare floatMin = 1;
// Clasă pentru stocarea golurilor cu indici de lumânări
clasa Gap {
pluti jos, sus;
int startIdx, endIdx; // indici ai lumânărilor
boolean bullish; // adevărat = gap bullish, fals = bearish
Gap(float l, float h, int început, int sfârșit, boolean bullishGap) {
scăzut = l;
înalt = h;
IdÎnceput = început;
endIdx = end;
bullish = bullishGap;
}
}
// Liste globale pentru FVG
ArrayList fvgUp = new ArrayList();
ArrayList fvgDn = new ArrayList();
// Detecție FVG (versiune simplificată și testabilă)
void detecteazăClustersAndFVG(float gapMin) {
fvgUp.clear();
fvgDn.clear();
pentru (int i=2; i
// --- FVG optimist ---
dacă (minime[i] - maxime[i-2] > gapMin) {
fvgUp.add(new Gap(maxime[i-2], minime[i], i-2, i, adevărat));
//ln("FVG UP:", maxime[i-2], "->", minime[i], "indici", i-2, "->", i);
}
// --- FVG pesimist ---
dacă (minime[i-2] - maxime[i] > gapMin) {
fvgDn.add(new Gap(maxime[i], minime[i-2], i-2, i, false));
//println("FVG DOWN:", maxime[i], "->", minime[i-2], "indici", i-2, "->", i);
}
}
}
// Desen FVG (dreptunghiuri orizontale „de la lumânare la lumânare”)
void drawFVG(float minP, float maxP) {
fărăAccident();
// FVG optimist
pentru (Gap g : fvgUp) {
float x1 = map(g.startIdx, 0, closes.length-1, 50, widths-50);
float x2 = map(g.endIdx, 0, closes.length-1, 50, widths-50);
float y1 = map(g.high, minP, maxP, height-50, 50);
float y2 = map(g.low, minP, maxP, height-50, 50);
fill(0, 255, 0, 90); // semitransparent vertical
accident vascular cerebral(0, 180, 0);
rect(x1, min(y1,y2), max(x2-x1, 2)+100, abs(y2-y1)); // lățime minimă 2px
fărăAccident();
umplere(255);
textAlign(STÂNGĂ, CENTRU);
text("FVG lung " + nf(g.low,0,2) + "-" + nf(g.high,0,2), x1 + 3, min(y1,y2) + abs(y2-y1)/2);
}
// FVG pesimist
pentru (Gap g : fvgDn) {
float x1 = map(g.startIdx, 0, closes.length-1, 50, widths-50);
float x2 = map(g.endIdx, 0, closes.length-1, 50, widths-50);
float y1 = map(g.high, minP, maxP, height-50, 50);
float y2 = map(g.low, minP, maxP, height-50, 50);
fill(0, 100, 255, 90); // albastru semitransparent
accident vascular cerebral(0, 0, 180);
rect(x1, min(y1,y2), max(x2-x1, 2)+100, abs(y2-y1)); // lățime minimă 2px
fărăAccident();
umplere(255);
textAlign(STÂNGĂ, CENTRU);
text("FVG scurt " + nf(g.low,0,2) + "-" + nf(g.high,0,2), x1 + 3, min(y1,y2) + abs(y2-y1)/2);
}
}
/*
Stocăm golurile ca perechi (scăzut, ridicat)
clasa Gap {
pluti jos, sus;
Gap(float l, float h) {
scăzut = l;
înalt = h;
}
}
ArrayList fvgUp = new ArrayList();
ArrayList fvgDn = new ArrayList();
void detecteazăClustersAndFVG() {
liquidationClusters.clear();
clusterCounts.clear();
fvgUp.clear();
fvgDn.clear();
// media simplă a volumului
float volMA = 0;
pentru (int i=0; i
volMA += volume[i];
}
volMA /= volumes.length;
pentru (int i=0; i
corp float = abs(închide[i]-deschide[i]);
lumânare float = maxime[i]-minime[i];
float wickUp = maxime[i]-max(se deschide[i], se închide[i]);
float wickDn = min(se deschide[i], se închide[i]) - minime[i];
// --- Lichidarea detectării clusterelor ---
dacă (volume[i] > volMA*volMult && lumânare > 0 && corp/lumânare <= minBodyRatio) {
float PrețLichid = Float.NaN;
dacă (wickUp/lumânare >= wickRatio) liquidPrice = maxime[i];
altfel dacă (wickDn/candle >= wickRatio) liquidPrice = lows[i];
dacă (!Float.isNaN(prețLichid)) addCluster(prețLichid);
}
*/
/*
// --- Detectarea diferențelor de valoare justă (FVG) ---
dacă (i >= 2) {
// FVG ascendent (minimul actual > maximul de acum 2 lumânări)
dacă (minime[i] > maxime[i-2]) {
//fvgUp.add(new Gap(maxime[i-2], minime[i]));
fvgUp.add(new Gap(maxime[i-2], minime[i]));
//fvgDn.add(new Gap(maxime[i], minime[i-2]));
}
// FVG bearish (maxim curent < minim de acum 2 lumânări)
dacă (maxime[i] < minime[i-2]) {
// fvgDn.add(new Gap(maxime[i], minime[i-2]));
// fvgUp.add(new Gap(maxime[i-2], minime[i]));
fvgDn.add(new Gap(maxime[i], minime[i-2]));
}
}
*/
/*
float gapMin = 1000; // toleranță minimă pentru a lua în considerare un FVG
dacă (i >= 2) {
// FVG optimist
dacă (minime[i] - maxime[i-2] > gapMin) {
fvgUp.add(new Gap(maxime[i-2], minime[i]));
println("FVG UP:", maxime[i-2], "->", minime[i]);
}
// FVG pesimist
dacă (minime[i-2] - maxime[i] > gapMin) {
fvgDn.add(new Gap(maxime[i], minime[i-2]));
println("FVG ÎN JOS:", maxime[i], "->", minime[i-2]);
}
}
}
}
void drawFVG(float minP, float maxP) {
fărăAccident();
// FVG verde ascendent
pentru (Gap g : fvgUp) {
float y1 = map(g.high, minP, maxP, height-50, 50);
float y2 = map(g.low, minP, maxP, height-50, 50);
accident vascular cerebral (255);
fill(0, 255, 0); // transparentă verticală
rect(50, y1, lățimi-100, y2-y1);
umplere(0, 180);
text("FVG" + nf(g.low,0,2)+"-"+nf(g.high,0,2), widths-490, y1+12);
}
// Urși albaștri FVG
pentru (Gap g : fvgDn) {
float y1 = map(g.high, minP, maxP, height-50, 50);
float y2 = map(g.low, minP, maxP, height-50, 50);
accident vascular cerebral (255,0,0);
fill(0, 100, 255); // albastru transparent
rect(50, y1, lățimi-100, y2-y1);
umplere(0, 180);
text("FVG" + nf(g.low,0,2)+"-"+nf(g.high,0,2), widths-490, y1+12);
}
}
*/
// --- DETECTAREA GRUPURILOR DE LICHIDARE ---
void detecteazăClusters() {
liquidationClusters.clear();
clusterCounts.clear();
// media simplă a volumului
float volMA = 0;
pentru (int i=0; i
volMA += volume[i];
}
volMA /= volumes.length;
pentru (int i=0; i
corp float = abs(închide[i]-deschide[i]);
lumânare float = maxime[i]-minime[i];
float wickUp = maxime[i]-max(se deschide[i], se închide[i]);
float wickDn = min(se deschide[i], se închide[i]) - minime[i];
dacă (volume[i] > volMA*volMult && lumânare > 0 && corp/lumânare <= minBodyRatio) {
float PrețLichid = Float.NaN;
dacă (wickUp/lumânare >= wickRatio) liquidPrice = maxime[i];
altfel dacă (wickDn/candle >= wickRatio) liquidPrice = lows[i];
dacă (!Float.isNaN(prețLichid)) addCluster(prețLichid);
}
}
}
// --- Grupează clustere apropiate ---
void addCluster(preț variabil) {
pentru (int i=0; i
dacă (abs(liquidationClusters.get(i) - preț) <= proximityPts) {
// incrementare
clusterCounts.set(i, clusterCounts.get(i)+1);
întoarcere;
}
}
liquidationClusters.add(preț);
număr_cluster.add(1);
}
// --- DETECTARE SUPORTURI + PAUZE ---
void detecteazăSuporturi() {
suportă.clear();
suportBroken.clear();
pentru (int i=pivotLeft; i
boolean isPivot = true;
pentru (int j=1; j<=pivotLeft; j++) dacă (minusuri[i] >= minime[i-j]) estePivot=false;
pentru (int j=1; j<=pivotRight; j++) dacă (minusuri[i] >= minime[i+j]) estePivot=false;
dacă (estePivot) {
float s = lows[i];
suportă.adăugați(e);
// pauză?
boolean broken = (closes[closes.length-1] < s);
suportBroken.add(rupt);
}
}
}
// --- Clustere de lichidare pe hartă termică ---
void drawClusters(float minP, float maxP) {
fărăAccident();
pentru (int i=0; i
nivel float = liquidationClusters.get(i);
int număr = numărCluster.get(i);
// maparea prețului la y
float y = map(lvl, minP, maxP, height-50, 50);
// Intensitate proporțională cu numărul de apariții
int alpha = constrângere(40 + număr*30, 40, 200);
int rectHeight = 6 + count*2; // înălțimePartea zonei
fill(255, 0, 0, alpha);
rect(50, y - rectHeight/2, lățimi-100, rectHeight);
// text discret în dreapta
umplere(255, 200);
text(lvl + "Cluster de lichidare x" + număr, lățimi - 490, y - 5);
}
}
// --- Suportă (zone verzi) ---
void drawSupports(float minP, float maxP) {
fărăAccident();
pentru (int i=0; i
nivel float = supports.get(i);
float y = map(lvl, minP, maxP, height-50, 50);
fill(0, 200, 0, 100); // verde translucid
rect(50, y-3, lățimi-100, 6);
umplere(0, 255, 0);
text(nivel+"Suport", 60, y-5);
}
}
// --- Întreruperi de suport (zone portocalii groase) ---
void drawBreaks(float minP, float maxP) {
fărăAccident();
pentru (int i=0; i
nivel float = supportBreaks.get(i);
float y = map(lvl, minP, maxP, height-50, 50);
fill(255, 140, 0, 150); // portocaliu semi-opac
rect(50, y-4, lățimi-100, 8);
umplere(255, 180, 0);
text("Pauză de asistență", 60, y-6);
}
}
///////########
// --- Analiză cluster pentru zone de cumpărare/vânzare ---
float clusterZoneMargin = 5f; // margine în jurul clusterului pentru a desena zona
void drawClusterZones(float minP, float maxP) {
pentru (int i=0; i
nivel float = liquidationClusters.get(i);
int număr = numărCluster.get(i);
// Preț de mapare -> și
float y = map(lvl, minP, maxP, height-50, 50);
// Definiți culoarea în funcție de tendință (de exemplu, evidențieri puternice = reducere, evidențieri slabe = cumpărare)
float wickUp = maxime[i] - max(se deschide[i], se închide[i]);
float wickDn = min(se deschide[i], se închide[i]) - minime[i];
boolean isBuyZone = wickDn > wickUp; // fitil mai mare pentru partea inferioară
boolean isSellZone = wickUp > wickDn; // fitil mai mare, mai sus
// Ajustează opacitatea și grosimea în funcție de numărul de apariții
int alpha = constrângere(60 + număr*30, 60, 200);
int rectHeight = 6 + număr*2;
dacă (esteZonăDeCumpărare) {
fill(0, 0, 255, alpha);
rect(50, y - clusterZoneMargin, lățimi-100, clusterZoneMargin*2);
umplere(0, 0, 255);
text("Cumpără x"+count, widths-180, y);
}
dacă (esteZonăDeVânzare) {
fill(255, 0, 0, alpha);
rect(50, y - clusterZoneMargin, lățimi-100, clusterZoneMargin*2);
umplere(255, 0, 0);
text("Vente x"+count, widths-180, y);
}
}
}
/////////€€
// --- Setări ---
float rsiSupracumpărat = 70f;
float rsiOversold = 45f;
int rsiLength = 27; // lungimea RSI
int shortTrendLength = 33; // numărul de lumânări pentru calcularea trendului scurt
float rectMargin = 10f; // grosimea dreptunghiului
// --- Calcul RSI simple ---
float calcRSI(float[] închide, int idx, int lungime) {
dacă (idx < lungime) returnează 50; // valoare neutră dacă nu sunt suficiente date
câștigul în plutitor = 0, pierderea = 0;
pentru (int i=idx-length+1; i<=idx; i++) {
float diff = închide[i] - închide[i-1];
dacă (diferența > 0) amplificare += diff;
altfel pierdere -= diff;
}
dacă (pierdere == 0) returnează 100;
returnează 100 - (100 / (1 + câștig/pierdere));
}
// --- Detectarea tendințelor pe termen scurt ---
boolean isShortDowntrend(float[] închide, int idx, int len) {
dacă (idx < len) returnează fals;
returnează închide[idx] < închide[idx-len];
}
boolean isShortUptrend(float[] închide, int idx, int len) {
dacă (idx < len) returnează fals;
returnează închide[idx] > închide[idx-len];
}
void drawTradeRectangles(float[] închideri, float[] maxime, float[] minime, float minP, float maxP) {
pentru (int i=lungimetrendscurtă; i
float rsi = calcRSI(închide, i, lungimeRsi);
// Calcularea poziției X în funcție de cronologie
float x = map(i, 0, closes.length-1, 50, widths-50);
// --- Semnal de vânzare ---
dacă (rsi >= rsiOverbought && isShortDowntrend(închide, i, shortTrendLength)) {
float recentHigh = maxime[i];
float y = map(recentHigh, minP, maxP, height-50, 50);
umplere(255, 0, 0, 80);
rect(x-10, y-rectMargin, 20, rectMargin*2); // dreptunghi centrat pe x
umplere(255, 0, 0);
text("S", x, y-rectMargin-5); // text chiar deasupra dreptunghiului
}
// --- Semnal de cumpărare ---
dacă (rsi <= rsiOversold && isShortUptrend(închide, i, shortTrendLength)) {
float recentLow = lows[i];
float y = map(recentLow, minP, maxP, height-50, 50);
umplere(0, 0, 255, 80);
rect(x-10, y-rectMargin, 20, rectMargin*2); // dreptunghi centrat pe x
umplere(0, 0, 255);
text("B", x, y-rectMargin-5); // text chiar deasupra dreptunghiului
}
}
}