C'è un modo per rendere meno lento il gestore dello stato di riga?È possibile fare in modo che il gestore dello stato di riga si attivi solo al passaggio del mouse o dopo il completamento di un evento di selezione?
L'evento in tempo reale provoca un ritardo nella selezione del trascinamento dal mio grafico e rende l'esperienza dell'utente spiacevole.
Sono arrivato al punto di riscrivere completamente un evento di selezione nella cosa della trappola per topi, ma ho problemi ad applicarlo agli istogrammi e non mi piace nemmeno come si comporta.
Soddisferebbe le mie esigenze se potessi utilizzare la casella di selezione dello strumento "Freccia(A)" contemporaneamente alla funzione trappola per topi in modo da poter semplicemente raccogliere le mie righe selezionate alla fine dell'evento moustrap invece di spararne un milione eventi trascinando il mouse.
Cose che non mi piacciono:
Più a lungo muovi il mouse mentre selezioni, sempre più script grafici inutili si accumulano nel grafico.
Vorrei averne solo uno e solo uno. Ho aggiunto un ciclo alla fine per eliminarli tutti dal grafico, motivo per cui sembrano "svanire".
Potrei semplicemente lasciarli lì, ma aggiungono rumore visivo al grafico e non so cosa succede quando ne ottieni troppi.
Modifica: quando ne ottieni troppi, iniziano a rallentare. Potrebbe essere più veloce distruggere il grafico e ricostruirlo piuttosto che eseguire il ciclo per rimuovere gli script grafici rimasti. Modifica 2: è molto più veloce distruggere il grafico e ricrearlo, ma poi lo zoom viene ripristinato, quindi dovrò catturare di più sullo stato del grafico in modo da poterlo ricostruire per nascondere l'aggiornamento all'utente.
Ho fatto in modo che le cose del clic Maiusc / Controllo funzionassero, sembra troppo confuso per la produzione. Soprattutto il clic di controllo ha questo lungo ritardo dopo il passaggio del mouse e la casella di selezione insegue il mouse anche quando hai già rilasciato il pulsante, penso che nel frattempo jmp stia gestendo un mucchio di eventi di trascinamento obsoleti prima che smetta di muoversi.
O semplicemente scarta l'intera avventura e trova un modo per avere un gestore dello stato di riga che si attiva con il mouse in alto (sarebbe l'ideale).
Esempi da cui ho preso in prestito il codice:
http://www.pega-analytics.co.uk/blog/segmented-regression/
https://community.jmp.com/t5/Discussions/Quick-way-to-compare-two-lists-and-identify-the-uncommon/td-p/5811
Names Default To Here(1);
dt = open("$sample_data\Iris.jmp");
MY_GRAPH_BUILDER = Graph Builder(
Size( 531, 456 ),
Show Control Panel( 0 ),
Variables( X( :Sepal length ), Y( :Sepal width ) ),
Elements( Points( X, Y, Legend( 3 ) ) ),
SendToReport(
Dispatch({},"Graph Builder",
FrameBox,
{Add Graphics Script(MouseTrap( MouseDown(x,y), MouseUp(x,y)))}
),
),
);
//MOUSE STUFF
get_box_dims = Function({firstX,lastX,firstY,lastY},
show("get_box_dims");
//show(firstX,lastX,firstY,lastY,modifier_key);
If (lastX>firstX,
max_x = lastX; min_x =firstX,
max_x = firstX;min_x =lastX,
);
If (lastY>firstY,
max_y = lastY; min_y =firstY,
max_y = firstY;min_y =lastY,
);
show(min_x,min_y,max_x,max_y);
evallist({min_x,max_x,min_y,max_y});
);
do_normal_select = Function({select_range},
show("normal_select");
dt << Select Where(
AsColumn(:Sepal length) >= select_range[1]
& AsColumn(:Sepal length) <= select_range[2]
& AsColumn(:Sepal width) >= select_range[3]
& AsColumn(:Sepal width) <= select_range[4]
);
);
do_shift_select = Function({select_range},
show("shift_select");
new_rows_to_add = as list(dt << Get Rows Where(
AsColumn(:Sepal length) >= select_range[1]
& AsColumn(:Sepal length) <= select_range[2]
& AsColumn(:Sepal width) >= select_range[3]
& AsColumn(:Sepal width) <= select_range[4]
)
);
if (length(new_rows_to_add) > 0,
curr_rows = as list(dt << Get Selected Rows);
rows_to_select = curr_rows || new_rows_to_add;
dt << Select Rows( rows_to_select);
);
show(new_rows_to_add,length(new_rows_to_add));
);
do_ctrl_select = Function({select_range},
show("ctrl_select");
new_rows_to_subtract = associativearray(as list(dt << Get Rows Where(
AsColumn(:Sepal length) >= select_range[1]
& AsColumn(:Sepal length) <= select_range[2]
& AsColumn(:Sepal width) >= select_range[3]
& AsColumn(:Sepal width) <= select_range[4]
)
));
if (length(new_rows_to_subtract) > 0,
curr_rows = associativearray(as list(dt << Get Selected Rows));
show("current_rows_selected",length(curr_rows));
show("number_rows_to_subtract",length(new_rows_to_subtract));
intersection=curr_rows;intersection<<INTERSECT></INTERSECT>
Miscelazione e pulizia dei datiQualità e ingegneria di processofinestreRi: C'è un modo per rendere meno lento il gestore dello stato di riga?Dubito che questo sia documentato molto bene, ovunque... @Audrey_Shull
MouseTrap e la funzione Handle con un comportamento simile non vengono eseguiti in linea come Rect() e l'altro normale funzioni di script grafici come Rect().
Quando il flusso di controllo nel tuo script grafico passa attraverso Handle() o MouseTrap(), la funzione non fa nulla nel caso di MouseTrap, o disegna un piccolo rettangolo nella posizione della maniglia per Handle. Quando si fa clic su un grafico con uno script grafico, JMP ricerca nello script le funzioni MouseTrap o Handle e le richiama, in ordine, fino a quando una di esse prende il punto.
Quindi, nel tuo esempio, finché non fai clic, il codice che imposta x0 non è mai stato eseguito. Ma il codice Rect verrà eseguito.
Credo che, senza provarlo, potresti avere diversi Handles() seguiti da un MouseTrap(), e JMP prenderebbe il punto di clic e lo passerebbe a ciascun Handle() finché uno di loro non lo prende, o il MouseTrap() che lo farà prendilo sempre.
Rect() può essere utilizzato in un ciclo for per disegnare molti rettangoli. Non puoi creare più handle inserendo Handle(...) in un ciclo. Se fosse necessario creare un numero variabile di handle, è possibile utilizzare MouseTrap() e un elenco di posizioni x,y per la ricerca oppure utilizzare una qualche forma di manipolazione delle espressioni per creare più chiamate Handle().
Ciò significa anche che MouseTrap/Handle deve trovarsi nello script grafico, non in una funzione utente richiamata dallo script grafico. Rect, d'altra parte, può trovarsi in una funzione utente richiamata dallo script grafico.
Se metti due MouseTrap in uno script grafico, credo che il secondo non possa mai essere raggiunto perché il primo accetterà sempre il clic.
New Window( "Example",
exx = 20,
exy = 50;
Graph Box(
Frame Size( 200, 200 ),
If( 0, // note that it still works
Mousetrap(
exx = x;
exy = y;
)
);
Circle( {0, 0}, Sqrt( exx * exx + exy * exy ) );
);
);Ri: C'è un modo per rendere meno lento il gestore dello stato di riga?Questo ha fatto un grande miglioramento. Grazie!
Ri: C'è un modo per rendere meno lento il gestore dello stato di riga?Ho provato questo ma ottenendo.
Names Default To Here(1);
dt = Open("$SAMPLE_DATA/Big Class.jmp");
gb = dt << Graph Builder(
Size(529, 457),
Show Control Panel(0),
Variables(X(:weight), Y(:height)),
Elements(Points(X, Y, Legend(3)))
);
fb = Report(gb)[FrameBox(1)];
i = 0;
fb << Add Graphics Script(
Mousetrap(
If(i == 0,
x0 = x; y0 = y;
);
exx = x; exy = y;
i++;
,
i = 0;
show("RELEASED");
);
Rect(x0, y0, exx, exy);
);
Nome irrisolto: x0 in accesso o valutazione di 'x0' , x0/*###*/
alla riga 24 in Script 2.jsl
Non ho molta familiarità con la trappola per topi(); funzione, non ha bisogno di 2x funzioni interne?
MouseTrap( MouseGiù(x,y), MouseSu(x,y)));
Voglio capirlo perché penso che gran parte del mio ritardo derivi dallo streaming dei punti in elenchi 2x e quindi dalla selezione del primo e dell'ultimo da quegli elenchi.
Ri: C'è un modo per rendere meno lento il gestore dello stato di riga?Userei semplicemente il pulsante (è quello che ho fatto), ma forse qualcosa potrebbe essere costruito con MouseTrap (o MouseBox?)
Names Default To Here(1);
dt = Open("$SAMPLE_DATA/Big Class.jmp");
gb = dt << Graph Builder(
Size(529, 457),
Show Control Panel(0),
Variables(X(:weight), Y(:height)),
Elements(Points(X, Y, Legend(3)))
);
fb = Report(gb)[FrameBox(1)];
i = 0;
fb << Add Graphics Script(
Mousetrap(
If(i == 0,
x0 = x; y0 = y;
);
exx = x; exy = y;
i++;
,
i = 0;
show("RELEASED");
);
Rect(x0, y0, exx, exy);
);Ri: C'è un modo per rendere meno lento il gestore dello stato di riga?È super lento.
Sto cercando di trasmettere le richieste http da JSL a un websertver per generare un dashboard live in tempo reale basato sulle selezioni jmp. Pensavo di poterlo fare con il gestore dello stato di riga, ma è così lento che uccide l'esperienza dell'utente. Una volta che raccogli più di 500 punti, le prestazioni precipitano.
Quello che ho in questo momento è fare una selezione sul grafico, fare clic su un pulsante, quindi viene visualizzato il rapporto http.
Voglio sbarazzarmi di quel clic del pulsante.
Quindi quello che sto cercando di fare ora è al momento del mouse, inviare un batch di dati al mio server http per generare la mia dashboard. Proprio come un evento javascript.
Ri: C'è un modo per rendere meno lento il gestore dello stato di riga?Per gli script multipli, puoi fare tutto in un singolo script e utilizzare un valore mancante in firstX per disattivarlo. Ecco un hack q&d per aggiungere solo una copia di un secondo script, o rinfrescare il grafico se non lo aggiungi, e usa ancora la tua logica per rimuoverlo quando hai finito.
MouseDown = Function( {px, py},
Insert Into( lstX, pX );
Insert Into( lstY, pY );
firstX = lstX[1];
lastX = lstX[N Items( lstX )];
firstY = lstY[1];
lastY = lstY[N Items( lstY )];
// quick and dirty hack to only add the script once
If( N Items( ((Report( MY_GRAPH_BUILDER )[FrameBox( 1 )]) << XPath( "//TopSeg" )) << get script ) < 2,
(Report( MY_GRAPH_BUILDER )[FrameBox( 1 )]) << Add Graphics Script(
Line Style( "solid" );
Fill Color( "BlueGreen" );
Transparency( 0.3 );
Rect( firstX, firstY, lastX, lastY, 1 );
);
, // ELSE make sure to redraw using new values (might work without this)
(Report( MY_GRAPH_BUILDER )[FrameBox( 1 )]) << inval << updatewindow;
);
);
Ri: C'è un modo per rendere meno lento il gestore dello stato di riga?Semplifica il seleziona dove espressione il più possibile. Non vedo il ritardo per 150 righe, ma per 100.000 righe è piuttosto brutto. Questo mi dà un miglioramento di 10 volte:
do_normal_select = Function( {select_range},
{start, stop, sr1, sr2, sr3, sr4},
//show("normal_select");
start = HP Time();
sr1 = select_range[1];
sr2 = select_range[2];
sr3 = select_range[3];
sr4 = select_range[4];
dt << Select Where( sr1 <= :Sepal length <= sr2 & sr3 <= :Sepal width <= sr4 );
// dt << Select Where(
// AsColumn(:Sepal length) >= select_range[1]
// & AsColumn(:Sepal length) <= select_range[2]
// & AsColumn(:Sepal width) >= select_range[3]
// & AsColumn(:Sepal width) <= select_range[4]
// );
stop = HP Time();
Write( Eval Insert( "\!nselect where ^stop-start^" ) );
);
Sono state apportate tre modifiche: rimozione di AsColumn, rimozione della sottoscrizione dal ciclo implicito e concatenamento dell'operatore di confronto.
@Audrey_Shull - Vorrei che il profiler funzionasse con questo. Il profiler si ferma prima che si apra la finestra, quindi non riesco mai a studiare il tempo trascorso nella selezione interattiva.
Ri: C'è un modo per rendere meno lento il gestore dello stato di riga?Cosa stai cercando di fare trascinando nella casella del frame di Graph Builder? Se si tratta di selezionare le righe e quindi rispondere, dovrebbe essere sufficiente un gestore dello stato di riga associato alla tabella di dati.
Ri: C'è un modo per rendere meno lento il gestore dello stato di riga?L'eliminazione delle stampe dovrebbe renderlo più veloce, anche nascondere la tabella dei dati potrebbe aiutare un po '. Anche controllare che ci sia qualche modifica "reale" tra due eventi può essere d'aiuto, ma a seconda dell'applicazione potrebbe essere difficile da controllare.
Ri: C'è un modo per rendere meno lento il gestore dello stato di riga?Sì, sono sempre stati difficili da usare.
Ho bisogno di qualcosa per ottenere una risposta in tempo reale, spero che il gestore dello stato di riga sia lento perché stava cercando di scrivere sulla console e che potrebbe essere più veloce per altre attività.
La riscrittura dei criteri di selezione funziona abbastanza bene per il mio grafico a dispersione anche se è un po' stravagante, d'altra parte i miei istogrammi di distribuzione non sembrano apprezzarlo.
Ri: C'è un modo per rendere meno lento il gestore dello stato di riga?Diversi gestori di stato sono un disastro in JMP e, a mio avviso, dovrebbero essere evitati se possibile. Ho creato un elemento della lista dei desideri per migliorarli Migliora i gestori dello stato di JMP (etichetta al passaggio del mouse, gestore dello stato della riga, gestore dello stato del filtro, utilità di pianificazione, ...)
