Przesuwanie wykresu myszką

[szybki]

Jako że jestem nowy na tym forum chciałbym wszystkich pozdrowić.
Jestem początkującym programistą i zwracam się z prośbą o pomoc.
Do rzeczy!

Mam pewien wykres w skali logarytmicznej. Potrzebuje dynamicznego przesuwania określonych punktów na tym wykresie na zasadzie przeciągania kursorem (może być pixel po pixelu). Niestety nie mam pojęcia jak to zrobić. Wykres jest rysowanay na dwóch PaintBox'ach (wymiar 300x300) - jeden odpowiada za skale logarytmiczną a drugi za sam wyrysowanie lini (wykresu). Dane pobierane są ze StringGrida (dwie kolumny - współrzędne x y)
Oto fragmenty kodu:

Rysowanie skali:

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

//funkcja rysująca skale logarytmiczną
void __fastcall TForm1::uklad_logarytmiczny()
{

        int i=0, j=0;
        int odl_dol=0;
        int odl_gorna=0;
        int odl_prawa=0;
        int odl_lewa=0;
        int szer_wyk=300;
        int wys_wyk=300;

       
        //ustawienie szerokosci i wysokosci
        PaintBox1->Width=301;//Form1->ClientWidth-300+1;
        PaintBox1->Height=301;//Form1->ClientHeight-300+1;

        PaintBox1->Canvas->Brush->Color=clWhite;
        PaintBox1->Canvas->Rectangle(1,1,300,300);
        //ustawienie koloru skali
        PaintBox1->Canvas->Pen->Color=clLtGray;

        //rysowanie skali logarytmicznej poziomej
        int k,l;

        for (l=0;l<3;l++)
        {
                for (k=1;k<10;k++)
                {
                        PaintBox1->Canvas->MoveTo(odl_lewa,l*(wys_wyk/3)+odl_gorna+(wys_wyk/3)-log10(k)*(wys_wyk/3));
                        PaintBox1->Canvas->LineTo(szer_wyk-odl_prawa,l*(wys_wyk/3)+odl_gorna+(wys_wyk/3)-log10(k)*(wys_wyk/3));
                }
        }

        //rysowanie skali logarytmicznej pionowej
        for (l=0;l<3;l++)
        {
                for (k=1;k<10;k++)
                {
                        PaintBox1->Canvas->MoveTo(l*(szer_wyk/3)+odl_lewa+log10(k)*szer_wyk/3,odl_gorna);
                        PaintBox1->Canvas->LineTo(l*(szer_wyk/3)+odl_lewa+log10(k)*szer_wyk/3,wys_wyk-odl_dol);
                }
        }

        // tworzenie ramki:
        PaintBox1->Canvas->Pen->Color=clBlack;

        // podzial poziomy ramki :
        for (i=0;i<4;i++)
        {
                PaintBox1->Canvas->MoveTo(odl_lewa,(odl_gorna+i*wys_wyk/3));
                PaintBox1->Canvas->LineTo(szer_wyk-odl_prawa,(odl_gorna+i*wys_wyk/3));
        }

        // podzial pionowy ramki:
        for (j=0;j<4;j++)
        {
                PaintBox1->Canvas->MoveTo(odl_lewa+j*szer_wyk/3,odl_gorna);
                PaintBox1->Canvas->LineTo(odl_lewa+j*szer_wyk/3,wys_wyk-odl_dol);
        }

}

Kreślenie wykresu:

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

void __fastcall TForm1::rysowanie_wykresu()
{

        PaintBox2->Repaint();
        PaintBox2->Width=301;//Form1->ClientWidth-300+1;
        PaintBox2->Height=301;//Form1->ClientHeight-300+1;

        PaintBox2->Canvas->Pen->Width =2;
        PaintBox2->Canvas->Pen->Color=clRed;

        for(int i=0;i<17;i++)
        {

                String a=StringGrid1->Cells[0][i];
                float  b = a.ToDouble() ;

                String c=StringGrid1->Cells[1][i];
                float  d = c.ToDouble();
                PaintBox1->Canvas->TextOutA((log10(b))*100,300-(log10(d))*100,i+1);

                PaintBox2->Canvas->MoveTo((log10(b))*100,300-(log10(d))*100);

                String e=StringGrid1->Cells[0][i+1];
                float  f = e.ToDouble();

                String g=StringGrid1->Cells[1][i+1];
                float  h = g.ToDouble();

                PaintBox2->Canvas->LineTo((log10(f))*100,300-(log10(h))*100);


        }
}

Da się uchwycić właśnie te konkretne pkt'y i przesunąć je jedynie góra dół (po y) i automatycznie zaktualizować dane w StringGrid'zie. Albo chociaż po przeciągnięciu punktu wyświetlić jego aktualną wartość (gdziekolwiek - dymek albo jakiś Edit/Memo)?

Jakby ktoś wiedział jak to zrobić na zwykłym liniowym wykresie chociaż, mógłbym przerobić to na mój log. Jak przeciągać jakiekolwiek pkty.

Czy w ogóle jet taka możliwość działania na PaintBox'ie? Czy może na jakimś innym komponencie?
Z góry dziękuję za jakąkolwiek pomoc.

[Cyfrowy Baron]

Całe to przesuwanie punktów może być realizowane tylko poprzez rysowanie na PaintBox, wiąże się to jednak z koniecznością odrysowywania całej zawartości PainBox, więc w przypadku dużych wykresów dynamiczne przeciąganie, czyli wizualizacja tego przeciągania może powodować duże opóźnienie w odrysowywaniu całego wykresu, a więc skokowe przesuwanie.

Jutro pomyślę jak by to można zrobić. Może wskazanie punktu i przeniesienie go w inne miejsce, wtedy wykres byłby przerysowywany tylko po ustawieniu punktu, jednak jak rozumiem wykres musi odrysować jakieś linie do nowego położenia, a to wymaga już jakiegoś algorytmu, który by tym zarządzał. To co ty podałeś tylko rysuje wykres, a tutaj trzeba jeszcze przechowywać wartości wszystkich punktów. Zadanie wydaje się dość złożone. Czy próbowałeś zrealizować to w TChart?

[szybki]

Dziękuje Baronie za poświęcenie czasu.

w przypadku dużych wykresów

Wykres jest bardzo prosty, jedynie 18 punktów pobieranych z Grida, i tylko te punkty są rozważane pod edycję (czyt. przesuwanie jedynie po osi y).

Może wskazanie punktu i przeniesienie go w inne miejsce, wtedy wykres byłby przerysowywany tylko po ustawieniu punktu, jednak jak rozumiem wykres musi odrysować jakieś linie do nowego położenia, a to wymaga już jakiegoś algorytmu, który by tym zarządzał.

Ciekawy trop.
Wskazanie danego pktu
przeciągnięcie go
pobranie nowej współrzędnej tego punktu na Paintboxie
zamiana tychże danych w konkretnej komórce Grida
przerysowanie wykresu po "puszczeniu" myszy z nowych wartości Grida
koniec.

Spróbuje to zrobić na najprostszym wykresie liniowym.

Czy próbowałeś zrealizować to w TChart?

Nigdy nie używałem tego komponentu i obawiam się problemów ze skalą logarytmiczną. Postaram się zapoznać z TCharem, może będzie prościej.

Jutro pomyślę jak by to można zrobić.

Dodam, że nie zależy mi na odnoszeniu sie do mojego konkretnego przypadku. Rysowanie prostego wykresu liniowego z danymi ze StringGrida wystarczy, przerobić później będzie prosto.


Edit: Niestety mój Borland nie posiada komponentu TChart

[szybki]

Mam pomysł jakby obejść "przeciąganie punktu".
Mianowicie można wykorzystać pobieranie wartości kursora po kliknięciu myszką (oczywiście tylko na Paintbox'ie)

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

POINT poz;  
        GetCursorPos(&poz);  

przerzucić współrzędne do Grida i Repaint() - oczywiście wszystko to w funkcji OnMouseDown. Tym sposobem wykres się bedzie zmieniał po kliknięciu - oczywiście pozostaje problem rozpoznania pktu który ma się przesunąć - na szczęście przesuwane są konkretne pkty o stałych wartościach X więc wystarczy tylko ograniczenie
Zabieram się do pracy.

[Cyfrowy Baron]

Już ten problem rozwiązałem. Problem stanowiło uchwycenie punktu, który wszak jest tylko elementem graficznym. Do tego musi istnieć pewien próg tolerancji dla każdego punktu, gdyż trafienie kursorem dokładnie w punkt byłoby niezwykle trudne. Ustawiłem więc sobie tolerancję na 10, po 5 z każdej strony punktu. Po wszystkim zauważyłem z pewnym zdziwieniem, że jeżeli nawet nałożę na siebie dwa punkty, to program i tak przesunie jeden punkt, co oczywiście nie jest dziełem przypadku, lecz tak wynika z kodu.

W kodzie, który tutaj proponuję punkty są przechowywane w tablicy asocjacyjnej i zmiana pozycji dowolnego punktu również oparta jest o tą tablicę. Sam wykres jest tylko graficzną interpretacją tej tablicy. Tabela StringGrid również wypełniana jest w oparciu o tą tablicę.
Kod jest bardzo złożony i będziesz musiał go dogłębnie przeanalizować, by go dostosować do swoich potrzeb, gdyż nie bazowałem wogóle na Twoim kodzie. Stworzyłem po prostu program, który rysuje wykres liniowy w oparciu o punkty wczytane z pliku tekstowego. Program pozwala przesuwać każdy punkt w czasie rzeczywistym.

Plik nagłówkowy Unit1.h

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

//---------------------------------------------------------------------------

#ifndef Unit1H
#define Unit1H
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include <ExtCtrls.hpp>
#include <Grids.hpp>
#include <map>
//---------------------------------------------------------------------------
class TForm1 : public TForm
{
__published:    // IDE-managed Components
        TButton *Button1;
        TPanel *Panel1;
        TPaintBox *PaintBox1;
        TStringGrid *StringGrid1;
        void __fastcall Button1Click(TObject *Sender);
        void __fastcall PaintBox1MouseMove(TObject *Sender, TShiftState Shift, int X,
          int Y);
        void __fastcall PaintBox1MouseDown(TObject *Sender, TMouseButton Button, TShiftState Shift,
          int X, int Y);
        void __fastcall PaintBox1MouseUp(TObject *Sender, TMouseButton Button, TShiftState Shift,
          int X, int Y);
        void __fastcall PaintBox1Paint(TObject *Sender);
private:        // User declarations
        std::map<int, TPoint> graphPoint;

        TPoint pbPoint;
        BOOL fDraw, bDrawGraph;
        int CurrentMapPoint;

        void __fastcall LoadPoints(String fileName);
        void __fastcall WriteToGrid(void);
        void __fastcall WriteCurrentGrid(TPoint gPoint);
        void __fastcall DrawCurrentPoint(void);
        void __fastcall DrawPoint(TPoint gPoint);
        void __fastcall DrawGraph(void);
        TPoint __fastcall FindPoint(int X, int Y);
public:         // User declarations
        __fastcall TForm1(TComponent* Owner);
};
//---------------------------------------------------------------------------
extern PACKAGE TForm1 *Form1;
//---------------------------------------------------------------------------
#endif

Plik źródłowy Unit1.cpp

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
#include <memory>
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"

using namespace std;

TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
 fDraw = false;
 bDrawGraph = false;
 CurrentMapPoint = -1;

 StringGrid1->Cells[0][0] = "Lp.";
 StringGrid1->Cells[1][0] = "Punkt X";
 StringGrid1->Cells[2][0] = "Punkt Y";
}
//---------------------------------------------------------------------------
void __fastcall TForm1::LoadPoints(String fileName)
{
 auto_ptr<TStringList> pointList(new TStringList());

 if(!FileExists(fileName)) return;

 pointList->LoadFromFile(fileName);

 graphPoint.clear();

 pointList->NameValueSeparator = ',';

 for(int c = 0; c < pointList->Count; c++)
 {
   int X = pointList->Names[c].ToIntDef(-1);
   int Y = pointList->ValueFromIndex[c].ToIntDef(-1);

   graphPoint[c] = TPoint(X, Y);
 }
}
//---------------------------------------------------------------------------
void __fastcall TForm1::WriteToGrid(void)
{
 int rCount = graphPoint.size();
 StringGrid1->RowCount = rCount + 1;

 for(int x = 1; x <= rCount; x++)
 {
  StringGrid1->Rows[x]->Clear();

  StringGrid1->Cells[0][x] = (String)x;
  StringGrid1->Cells[1][x] = (String)graphPoint[x - 1].x;
  StringGrid1->Cells[2][x] = (String)graphPoint[x - 1].y;
 }
}
//---------------------------------------------------------------------------
void __fastcall TForm1::WriteCurrentGrid(TPoint gPoint)
{
 StringGrid1->Cells[1][CurrentMapPoint + 1] = (String)gPoint.x;
 StringGrid1->Cells[2][CurrentMapPoint + 1] = (String)gPoint.y;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::DrawCurrentPoint(void)
{
 TCanvas *pbCanv = PaintBox1->Canvas;

 pbCanv->Pen->Color = clBlack;
 pbCanv->Pen->Width = 2;

 if(CurrentMapPoint > 0)
 {
  int X1 = graphPoint[CurrentMapPoint - 1].x;
  int Y1 = graphPoint[CurrentMapPoint - 1].y;
  pbCanv->MoveTo(X1, Y1);
  pbCanv->LineTo(pbPoint.x, pbPoint.y);
 }

 if((UINT)CurrentMapPoint < graphPoint.size())
 {
  int X1 = graphPoint[CurrentMapPoint + 1].x;
  int Y1 = graphPoint[CurrentMapPoint + 1].y;
  pbCanv->MoveTo(pbPoint.x, pbPoint.y);
  pbCanv->LineTo(X1, Y1);
 }

 pbCanv->Pen->Color = clRed;
 pbCanv->Pen->Width = 10;
 pbCanv->MoveTo(pbPoint.x, pbPoint.y);
 pbCanv->LineTo(pbPoint.x, pbPoint.y);

 WriteCurrentGrid(pbPoint);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::DrawPoint(TPoint gPoint)
{
 TCanvas *pbCanv = PaintBox1->Canvas;

 pbCanv->Pen->Color = clRed;
 pbCanv->Pen->Width = 10;
 pbCanv->MoveTo(gPoint.x, gPoint.y);
 pbCanv->LineTo(gPoint.x, gPoint.y);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::DrawGraph(void)
{
 if(graphPoint.size() == 0) return;

 TCanvas *pbCanv = PaintBox1->Canvas;

 pbCanv->Pen->Color = clBlack;
 pbCanv->Pen->Width = 2;

 for(UINT x = 1; x < graphPoint.size(); x++)
 {
   int X1 = graphPoint[x - 1].x;
   int Y1 = graphPoint[x - 1].y;

   int X2 = graphPoint[x].x;
   int Y2 = graphPoint[x].y;

   pbCanv->MoveTo(X1, Y1);
   pbCanv->LineTo(X2, Y2);
 }

 for(UINT x = 0; x < graphPoint.size(); x++)
 {
  DrawPoint(graphPoint[x]);
 }

 WriteToGrid();
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
 LoadPoints( ExtractFilePath(Application->ExeName) + "points.txt" );

 bDrawGraph = true;

 PaintBox1->Repaint();
}
//---------------------------------------------------------------------------
TPoint __fastcall TForm1::FindPoint(int X, int Y)
{
  TPoint Result(-1, -1);

  UINT x = 0;

  do
  {
  // if(PaintBox1->Canvas->Pixels[X][Y] == clRed)
  // {
    if( (graphPoint[x].x - X <= 5 && graphPoint[x].x - X >= -5) &&
        (graphPoint[x].y - Y <= 5 && graphPoint[x].y - Y >= -5)
      )
    {
      CurrentMapPoint = x;
      return graphPoint[x];
    }
  // }
   x++;
  }while(x < graphPoint.size());

 CurrentMapPoint = -1;
 return Result;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::PaintBox1MouseDown(TObject *Sender, TMouseButton Button,
          TShiftState Shift, int X, int Y)
{
 if(CurrentMapPoint >= 0)
 {
  fDraw = true;
 }
 else
 {
  fDraw = false;
 }
}
//---------------------------------------------------------------------------
void __fastcall TForm1::PaintBox1MouseMove(TObject *Sender, TShiftState Shift,
          int X, int Y)
{
 if(fDraw == false)
 {
  pbPoint = FindPoint(X, Y);
 }
 else
 {
  PaintBox1->Canvas->Pen->Mode = pmNotXor;

  DrawCurrentPoint();

  pbPoint.x = X;
  pbPoint.y = Y;

  DrawCurrentPoint();
 }
}
//---------------------------------------------------------------------------
void __fastcall TForm1::PaintBox1MouseUp(TObject *Sender, TMouseButton Button,
          TShiftState Shift, int X, int Y)
{
 if(CurrentMapPoint >= 0)
 {
  pbPoint.x = X;
  pbPoint.y = Y;

  fDraw = false;

  PaintBox1->Canvas->Pen->Mode = pmCopy;

  graphPoint[CurrentMapPoint] = pbPoint;

  PaintBox1->Repaint();
 }
}
//---------------------------------------------------------------------------

void __fastcall TForm1::PaintBox1Paint(TObject *Sender)
{
 if( bDrawGraph )DrawGraph();
}
//---------------------------------------------------------------------------

---

[polymorphism]

W kodzie, który tutaj proponuję punkty są przechowywane w tablicy asocjacyjnej

Użycie mapy w tym przypadku jest zbędne, wystarczy vector. Miej na względzie to, że dostęp do elementu poprzez operator [] ma złożoność logarytmiczną (dla porównania, zwykła tablica ma złożoność stałą).

[Cyfrowy Baron]

Vector rzeczywiście by wystarczył, gdyż mapa w zasadzie przechowuje tylko wartości typu TPoint, a indeks jest tylko kolejnym elementem. Pierwotne założenie było jednak inne i początkowo eksperymentowałem z taką tablicą:

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

std::mp<TPoint, int> graphPoint;

gdyż zamierzałem skorzystać z funkcji find, lecz jak się okazało, TPoint nie może być kluczem mapy. Nie zmieniłem tego i już nie będę zmieniał, jak ktoś ma ochotę niech podstawi sobie vector, zmiany w kodzie będą niewielkie.

[szybki]

Dziękuję za (uwagę, pomoc i kod)=czas.

Mam tez następny problem. Bardziej chyba jest to problem natury matematycznej ale może ktoś bedzie miał jakąś radę.
Lepiej przedstawie problem w wersji "pseudowizualnej":


Postawię jeszcze raz pytanie: jak wrócić z wartości x na wartość logarytmiczną a?


//chyba w sumie nie ten dział na posta ale nie wiem gdzie się zapytać

[polymorphism]

Jeśli:

wtedy:

Wystarczyło zajrzeć do jakiegoś opisu logarytmów...