max value in an Array

ermina

In the code bellow i load a csv file and i want to find the maximum value from the column.. Where the name(header) of the column in the csv file is values. But i get the error NullPointerException

    String filename = "abc.csv";
    String[] rawData;
    float[] values;

    void setup() {
      rawData = loadStrings(filename);
      for (int i=1; i<rawData.length; i++) {
        String[] thisRow = split(rawData[i], ",");
        values[i-1] = int(thisRow[1]);

      }

    if (values.length == 0) 
    {
      println("nothing in the array.");

    } else {
      float maxValue =  values[0];
      int maxIndex = 0;
      for (int i = 1; i <  values.length; i++) {
        if ( values[i] > maxValue) {
      maxValue = values[i];
      maxIndex = i;
        }
      }
      print("max value is " + maxValue);
      println(" at position " + maxIndex);
    }
      }


    void draw() {

    }

TfGuy44

We've moved to a new Forum...

Your code doesn't set up the values array anywhere. You'll need a line somewhere like this:

values = new float[some_size];

How big does it need to be?

ermina

And what about this forum??Will it close??

GoToLoop

For ".csv" & ".tsv" files, use loadTable() in place of loadStrings():
https://Processing.org/reference/loadTable_.html
table = loadTable("abc.csv", "header");

Then, set the datatype of the "values" column: table.setColumnType("values", Table.INT);

Now let's sort that "values" column via method sortReverse():
https://Processing.org/reference/Table_sort_.html
table.sortReverse("values");

Now we know the TableRow w/ the max value in column "values" is the 1st 1 (index 0):
https://Processing.org/reference/Table_getInt_.html
int maxValue = table.getInt(0, "values");

Of course I'm assuming the values within column "values" are of datatype int:
https://Processing.org/reference/int.html

If they're floatinstead instead: https://Processing.org/reference/float.html
Simply replace Table.INT w/ Table.FLOAT & getInt() w/ getFloat():
https://Processing.org/reference/Table_getFloat_.html

ermina

Thank you so much @GoToLoop

ermina

Something more...How can i locate the corresponding value to the maxvalue in the other column?For example at y axes the maximum value is 5,7 that corresponds at value 0.35 in x axes.

ermina

I read about

                          'TableRow result = table.findRow("maxValue", "values");
                          println(result.getString("name"));'

but when i add this function to my programm, i ''ll get the error of NullPointerException

ermina

@GoToLoop any idea???

ermina

this is the code bellow :

            Table table;

            void setup(){

              table=loadTable("intensity_time.csv","header");
              table.setColumnType("Intensity", Table.FLOAT);
              table.sortReverse("Intensity");
              float  maxValue = table.getFloat(0, "Intensity");
              table.setColumnType("Time", Table.FLOAT);
              for (int row = 0; row < table.getRowCount(); row++) {
                float Time = table.getFloat(row, 0);
               float Intensity = table.getFloat(row, 1);
             }


              TableRow maxTime= table.findRow("maxValue","Intensity");
                    //float maxTime=table.getFloat(row, "Time");

               print("max value is " + maxValue +" at time " + maxTime );
              // println(maxTime);
               //println(result.getFloat("Time"));

             }

ermina

and the csv file is bellow:

                                        Time,Intensity
                                        5,0.2
                                        10,0.4
                                        15,0.4
                                        20,0.3
                                        25,0.6
                                        30,0.6
                                        35,0.9
                                        40,0.7
                                        45,0.5
                                        50,0.5
                                        55,0.3
                                        60,0.1
                                        65,0.3
                                        70,0.5
                                        75,0.6
                                        80,0.4
                                        85,0.3
                                        90,0.1
                                        95,0.1
                                        100,0.2

ermina

now after i run this code i 'll get this message:

max value is 0.9 at time null

But i do not know why maxTime is null

GoToLoop

Method Table::findRow() is for seeking out the 1st TableRow it finds which contains a specific element within a column: :-B
https://Processing.org/reference/Table_findRow_.html

It's a dumb vanilla searching though. It isn't smart enough for finding out elements which match a customized conditional test, such as: :@)

1. Get me the TableRow which got the highest value within a specified column.
2. Or get me all of the TableRow objects which got a range from -3 to 5.5 within a specified column.

B/c the Table class doesn't provide such advanced filtering methods, we'd need to write our own! #:-S

kfrajer

You might need to store your data in a hash map and use functions available in java for these containers. If you do a search in the forum, you can find some examples where this has already been done. These should not be difficult to implement as you only have two columns. If you have more columns, then there is the challenge to manage them all together. Read this just as a little bit extra work.

Try implementing the hashmap and post your code, and I should be able to assist tonight.

Kf

ermina

So i did not understand what am i supposed to do?What's the next step???

GoToLoop

What am I supposed to do?

I've already stated: If a class doesn't provide the features we need we'd need to write our own! 8-X

So you're now requesting the TableRow w/ the max value for both columns "Time" & "Intensity".

This is the function I've just written for it. Still untested though: :-\"

static final TableRow findRowMaxValue(final Table t, final String colName) {
  return findRowMaxValue(t, t.getColumnIndex(colName));
}

static final TableRow findRowMaxValue(final Table t, final int colIdx) {
  TableRow foundRow = null;
  float maxVal = MIN_FLOAT;

  for (final TableRow tr : t.rows()) {
    final float f = tr.getFloat(colIdx);

    if (f > maxVal) {
      maxVal = f;
      foundRow = tr;
    }
  }

  return foundRow;
}

ermina

i test it but nothing...

ermina

If i have a bigger csv file, in which there is a max value about every 100seconds or 100 values..Is there a way to find how many max values appear in 1 minute for example.How many times do i have a beat or a pulse(max value) in one minute.. I think this is more helpfull for my project than finding the row of the maxValue.

jeremydouglass

Is there a way to find how many max values appear in 1 minute for example.

This is beat detection aka peak detection aka finding local maxima. There are hundreds of implementations of a basic sliding window out there if you search those terms + Processing or + Java-- you may want to use an existing library or algorithm for this, rather than write your own.

ermina

Could you please give me an example or provide me a page..I am lost on the internet but i couldn't find something similar..

jeremydouglass

Here is the top search hit, which contains an example of working code marked as an answer:

https://stackoverflow.com/questions/13157510/finding-the-local-min-max-in-a-1d-array-histogram

kfrajer

There is an example that you could explore using hashMaps here: https://forum.processing.org/two/discussion/26371/how-to-create-a-heatmap-from-list-of-x-y-points

You don't have to use this but you could explore it and see if it could fit your project.

which there is a max value about every 100seconds or 100 values..Is there a way to find how many max values appear in 1 minute for example.How many times do i have a beat or a pulse(max value) in one minute

You need to design this part. It is hard to do this part as we don't own your project and we don't know anything about your design. For example, checking the max every 100 seconds or 100 points are two different things, unless if you are collecting 1 pt every seconds, so doing it either way should be the same. However, we do not know the sampling rate of your data, the size of your data, the format of your data, the structure of your table, and how everything fits together. Remember, every time we come back to a post, we forget the details about the post. This is my approach. Unfortunately I cannot go back and read the previous comments to figure out if something has change in your project. The best thing you can do is to provide a question with all the needed details and as concise as possible.

Also it is important to provide a sample data set. This way everybody should aim to get the same result and removes a level of complexity.

Kf

ermina

I want to find the rate of the plot or the rate of the intensity…So my plan is to find the max values of the intensity and then in which time.So then i can calculate how many times i one period (time interval) i have max values.After that i will have find the rate which is times(that the max values of signal appears) per period(time).For example here i see from the plot that i have 2 max values about every 200(time) but i want these to make it java code for processing.

           void setup(){

          table=loadTable("intensity_time.csv","header");
          table.setColumnType("Intensity", Table.FLOAT);
          table.sortReverse("Intensity");
          float  maxValue = table.getFloat(0, "Intensity");
          table.setColumnType("Time", Table.FLOAT);
          for (int row = 0; row < table.getRowCount(); row++) {
            float Time = table.getFloat(row, 0);
           float Intensity = table.getFloat(row, 1);
         }


          TableRow maxTime= table.findRow("maxValue","Intensity");
                //float maxTime=table.getFloat(row, "Time");

           print("max value is " + maxValue +" at time " + maxTime );
          // println(maxTime);
           //println(result.getFloat("Time"));

         }

ermina

and the dataset:

                                Time,Intensity
                                10,0.2
                                20,0.4
                                30,0.4
                                40,0.3
                                50,0.6
                                60,0.6
                                70,0.9
                                80,0.7
                                90,0.5
                                100,0.5
                                110,0.3
                                120,0.1
                                130,0.3
                                140,0.5
                                150,0.6
                                160,0.4
                                170,0.3
                                180,0.1
                                190,0.1
                                200,0.2
                                210,0.2
                                220,0.3
                                230,0.1
                                240,0.2
                                250,0.5
                                260,0.6
                                270,0.6
                                280,0.7
                                290,1.2
                                300,1.3
                                310,1.1
                                320,0.9
                                330,0.6
                                340,0.6
                                350,0.5
                                360,0.3
                                370,0.3
                                380,0.1
                                390,0.1
                                400,0.2
                                410,0.4
                                420,0.4
                                430,0.6
                                440,0.6
                                450,0.7
                                460,0.7
                                470,0.7
                                480,0.9
                                490,1
                                500,0.8
                                510,0.5
                                520,0.5
                                530,0.2
                                540,0.2
                                550,0.2
                                560,0.1
                                570,0.1
                                580,0.1
                                590,0.2
                                600,0.2
                                610,0.2
                                620,0.6
                                630,0.6
                                640,0.5
                                650,0.5
                                660,0.5
                                670,0.8
                                680,0.8
                                690,0.9
                                700,0.9
                                710,0.9
                                720,0.9
                                730,1.2
                                740,1.6
                                750,1.3
                                760,1.1
                                770,0.8
                                780,0.8
                                790,0.8
                                800,0.5
                                810,0.3
                                820,0.3
                                830,0.1
                                840,0.1
                                850,0.2
                                860,0.2
                                870,0.2
                                880,0.5
                                890,0.5
                                900,0.7
                                910,0.8
                                920,0.8
                                930,0.9
                                940,0.9
                                950,0.9
                                960,1.2
                                970,1.4
                                980,1.1
                                990,1
                                1000,0.8
                                1010,0.8
                                1020,0.7
                                1030,0.5
                                1040,0.5
                                1050,0.2
                                1060,0.2
                                1070,0.1
                                1080,0.1
                                1090,0.3
                                1100,0.5
                                1110,0.6
                                1120,0.9
                                1130,1.2
                                1140,1.8
                                1150,1.6
                                1160,1.5
                                1170,1.2
                                1180,1.1
                                1190,0.9
                                1200,0.9
                                1210,0.7
                                1220,0.5
                                1230,0.3
                                1240,0.1
                                1250,0.3
                                1260,0.5
                                1270,0.6
                                1280,0.4
                                1290,0.3
                                1300,0.1
                                1310,0.1
                                1320,0.2
                                1330,0.2
                                1340,0.3
                                1350,0.1
                                1360,0.2
                                1370,0.5
                                1380,0.6
                                1390,0.6
                                1400,0.7
                                1410,1.2
                                1420,1.3
                                1430,1.1
                                1440,0.9
                                1450,0.6
                                1460,0.6
                                1470,0.4
                                1480,0.6
                                1490,0.6
                                1500,0.5
                                1510,0.5
                                1520,0.3
                                1530,0.2
                                1540,0.2
                                1550,0.3
                                1560,0.5
                                1570,0.5
                                1580,0.2
                                1590,0.2
                                1600,0.2
                                1610,0.1
                                1620,0.1
                                1630,0.1
                                1640,0.2
                                1650,0.2
                                1660,0.2
                                1670,0.6
                                1680,0.6
                                1690,0.7
                                1700,1.2
                                1710,1.3
                                1720,1.1
                                1730,0.9
                                1740,0.6
                                1750,0.6
                                1760,0.5
                                1770,0.3
                                1780,0.3
                                1790,0.1
                                1800,0.1
                                1810,0.2
                                1820,0.1
                                1830,0.1
                                1840,0.2
                                1850,0.2
                                1860,0.2
                                1870,0.5
                                1880,0.5
                                1890,0.7
                                1900,0.8
                                1910,0.9
                                1920,1.2
                                1930,1.4
                                1940,1.1
                                1950,1
                                1960,0.7
                                1970,0.7
                                1980,0.3
                                1990,0.3
                                2000,0.2

kfrajer

The code you posted above detects the maximum as it will be the first entry in the data set after it is reverse sorted.

For example here i see from the plot that i have 2 max values about every 200(time) but i want these to make it java code for processing.

How to find more than one maximum? You take the second entry and see if it classifies as a maximum of interest. In general, you can have more max values in you data set if they all have the same value. The algorithm below (a copy of yours) only shows the first max value. In case of multiple max values, it will show only the first one found in the list.

• To show multiple max values that are the same value, you need to iterate through top elements in the list.

• If you have multiple max values that are not the same value, then you need to set a threshold. Anything above a threshold is a max value, and you process them accordingly.

Simplified version of your code below.

Kf

final int ROWZERO=0;
final int COL_TIME=0;
final int COL_INTENSITY=1;

Table table;
void setup() {

  table=loadTable("data.csv", "header");

  table.setColumnType("Time", Table.INT);
  table.setColumnType("Intensity", Table.FLOAT);

  table.sortReverse("Intensity");

  //float  maxValue = table.getFloat(0, "Intensity");  ***EDIT

  int time = table.getInt(ROWZERO, COL_TIME);
  float intensity = table.getFloat(ROWZERO, COL_INTENSITY);
  println("Max value is " + intensity +" at time " + time  );

}

ermina

If you have multiple max values that are not the same value, then you need to set a threshold. Anything above a threshold is a max value, and you process them accordingly.

If i set a threshold, how can i know **how many times **in one period or in one second will i have max values, values that are above threshold.

kfrajer

If i set a threshold, how can i know **how many times **in one period or in one second

You capture the max values and their respective times. Setting up a threshold is one approach. It depends on the nature of your data. For instance, if you are collecting data regarding sun intensity as detected by a single sensor on a single spot during a day, you will have a maximum when the sun is right above the sensor (at noon). Notice this gives you not a single max but a range of max that could be in hours. Now, if you have cloud coverage, your sensor will detector the cloud coverage and you have max only when the sensor is not covered by a cloud.

The nature of the data dictates how to extract the maximum values.

In your data, you can have a look at your values and see if they do show up as single entries every so many entries. if it doesn't, then before implementing anything else, you will need to strictly defined how to extract the ma values (of interest) from your data set and based on this, one implements the algorithm. I hope this is clear.

This would be a good opportunity to explore Processing-R flavour to access some stat tools.

Kf

ermina

i did not understand this part :

In your data, you can have a look at your values and see if they do show up as single entries every so many entries. if it doesn't, then before implementing anything else, you will need to strictly defined how to extract the ma values (of interest) from your data set and based on this, one implements the algorithm.

But to explain you more..In the photo bellow the intensity is shows up..As you see in the graph there are about 3 max values(values above 0.8) every second..This is what i want to describe with java code..I want a function that can calculate how many times has max value( value above 0.8) per second(in one second).

ermina

kfrajer

Please provide this data set. If you want to detect each peak, then you need to [1]set a threshold, [2]extract values above threshold and [3] pick each section's centroid.

Kf

ermina

This is the dataset:

Time,Intensity 10,0.2 20,0.4 30,0.4 40,0.3 50,0.6 60,0.6 70,0.9 80,0.7 90,0.5 100,0.5 110,0.3 120,0.1 130,0.3 140,0.5 150,0.6 160,0.4 170,0.3 180,0.1 190,0.1 200,0.2 210,0.2 220,0.3 230,0.1 240,0.2 250,0.5 260,0.6 270,0.6 280,0.7 290,1.2 300,1.3 310,1.1 320,0.9 330,0.6 340,0.6 350,0.5 360,0.3 370,0.3 380,0.1 390,0.1 400,0.2 410,0.4 420,0.4 430,0.6 440,0.6 450,0.7 460,0.7 470,0.7 480,0.9 490,1 500,0.8 510,0.5 520,0.5 530,0.2 540,0.2 550,0.2 560,0.1 570,0.1 580,0.1 590,0.2 600,0.2 610,0.2 620,0.6 630,0.6 640,0.5 650,0.5 660,0.5 670,0.8 680,0.8 690,0.9 700,0.9 710,0.9 720,0.9 730,1.2 740,1.6 750,1.3 760,1.1 770,0.8 780,0.8 790,0.8 800,0.5 810,0.3 820,0.3 830,0.1 840,0.1 850,0.2 860,0.2 870,0.2 880,0.5 890,0.5 900,0.7 910,0.8 920,0.8 930,0.9 940,0.9 950,0.9 960,1.2 970,1.4 980,1.1 990,1 1000,0.8 1010,0.8 1020,0.7 1030,0.5 1040,0.5 1050,0.2 1060,0.2 1070,0.1 1080,0.1 1090,0.3 1100,0.5 1110,0.6 1120,0.9 1130,1.2 1140,1.8 1150,1.6 1160,1.5 1170,1.2 1180,1.1 1190,0.9 1200,0.9 1210,0.7 1220,0.5 1230,0.3 1240,0.1 1250,0.3 1260,0.5 1270,0.6 1280,0.4 1290,0.3 1300,0.1 1310,0.1 1320,0.2 1330,0.2 1340,0.3 1350,0.1 1360,0.2 1370,0.5 1380,0.6 1390,0.6 1400,0.7 1410,1.2 1420,1.3 1430,1.1 1440,0.9 1450,0.6 1460,0.6 1470,0.4 1480,0.6 1490,0.6 1500,0.5 1510,0.5 1520,0.3 1530,0.2 1540,0.2 1550,0.3 1560,0.5 1570,0.5 1580,0.2 1590,0.2 1600,0.2 1610,0.1 1620,0.1 1630,0.1 1640,0.2 1650,0.2 1660,0.2 1670,0.6 1680,0.6 1690,0.7 1700,1.2 1710,1.3 1720,1.1 1730,0.9 1740,0.6 1750,0.6 1760,0.5 1770,0.3 1780,0.3 1790,0.1 1800,0.1 1810,0.2 1820,0.1 1830,0.1 1840,0.2 1850,0.2 1860,0.2 1870,0.5 1880,0.5 1890,0.7 1900,0.8 1910,0.9 1920,1.2 1930,1.4 1940,1.1 1950,1 1960,0.7 1970,0.7 1980,0.3 1990,0.3 2000,0.2

kfrajer

Based on your data, this should do it. I get the following output:

Number of peaks = 9
70.0 0.9
280.0 1.1204919
470.0 0.8993197
720.0 0.98640674
950.0 0.9647727
1130.0 1.2307471
1400.0 1.1240351
1690.0 1.1241982
1910.0 1.0674459

Notice that while finding the max peak intensity is sort of robust, finding the time of this maximum is not. The provided algorithm provides a time associated to the peak biased toward the left (aka. earliest time).

Kf

import java.util.Map;


final int ROWZERO=0;
final int COL_TIME=0;
final int COL_INTENSITY=1;
final float THRESH=0.8;

Table table;
ArrayList<PVector> timePeakPair;

void setup() {

  table=loadTable("data.csv", "header");
  timePeakPair=new ArrayList<PVector>();

  table.setColumnType("Time", Table.INT);
  table.setColumnType("Intensity", Table.FLOAT);


  boolean aboveThresh=false;
  int ctr=0;
  float sum_xfx=0;
  float sum_x=0;
  int rowBeginSection=-1;

  //Next for loop traverses data from left to right.
  //When a data point is above the threshold, it 
  //creates a window where it stores the start position
  //of the data in the array and store time/intensity
  //values. As soon as data goes below threshold, a
  //peak and time associated to peak is calculated and
  //stored in peak container array.

  for (int i=0; i<table.getRowCount(); i++) {

    int time = table.getInt(i, COL_TIME);
    float intensity = table.getFloat(i, COL_INTENSITY);

    if (intensity>=THRESH) {  //Above or equal

      aboveThresh=true;

      sum_xfx+=time*intensity;
      sum_x+=time;  //Store the first time entry
      ctr+=1;
      if (rowBeginSection<0) rowBeginSection=i;

      //println(ctr,sum_x,sum_xfx);
    } else {

      //If finish a section above threshold, calculate peak follow by reseting fields
      if (aboveThresh==true) {

        //Calculating...        
        float intPeak=sum_xfx/sum_x;  
        float timePeak=getTimeEntry(rowBeginSection, intPeak, ctr); //sum_x/ctr;
        PVector pt = new PVector(timePeak, intPeak);
        timePeakPair.add(pt);        
        //println("CALC: ", ctr, timePeak, intPeak);

        //Reseting...
        sum_xfx=0;
        sum_x=0;
        ctr=0;
        rowBeginSection=-1;
        aboveThresh=false;
      }
    }
  }

  //REPORT:
  println("Number of peaks = "+timePeakPair.size());
  for (PVector pt : timePeakPair) {
    println(pt.x, pt.y);
  }
}


/**
* Next algorithm roughly estimates the time associated to peak.
* This algorithm is by no means robust but it does the job based
* on the following assumptions:
* [1] There is only one peak in the data set
* [2] The parameter peakValue is below the max value of the peak (peak can be easily pin point)
* [3] In other words, the peak looks like a single Guassian curve (No duplets)
*
* The algorithm returns the time associated to the bin if there is one point 
* in the window. Otherwise, it returns the left point (earlier) point
* associated to the peak.
*/
float getTimeEntry(int rowStart, float peakValue, int ctr) {

  //Trivial case
  if (ctr==1)
    return table.getInt(rowStart, COL_TIME);

  float ctime=-1;  
  for (int i=rowStart; i<rowStart+ctr+1; i++) { 
    int time = table.getInt(i, COL_TIME);
    float intensity = table.getFloat(i, COL_INTENSITY);


    if (intensity>peakValue) {      
      int idx=i-1;
      ctime=table.getInt(idx, COL_TIME);    
      break;
    }
  }

  return ctime;
}

ermina

Thank you for your time and of course for your help..I will study this code because it is a little hard for me..But this programm shows the max value and its corresponding time..Especially i want to find how many times in one second there are peaks, for examlpe to show me that in one second there are 3 max values...

kfrajer

Consider this data

Number of peaks = 9
70.0 0.9
280.0 1.1204919
470.0 0.8993197
720.0 0.98640674
950.0 0.9647727
1130.0 1.2307471
1400.0 1.1240351
1690.0 1.1241982
1910.0 1.0674459

This data is time-peakValue info. If you take the time interval of your data set and divide by the number of peaks, you get the rate these peaks occurs.

Max-peak-rate = numberOfPeaks / (endTimeDataSet - startTimeDataSet)

Based on your data, assuming time in seconds and for a threshold of 0.8 [intensity units]:

Max-peak-rate = 9 / (2000 - 0 ) = 0.0045 Hz

In other words, you get a peak about every 222 seconds. Notice for this task you do not need to know the time those peaks occurred. You only need to count those peaks.

Kf

ermina

Thank you so much...It was very helpfull this code to me...I have one more question:

What does this function bellow exactly?

        `   if (intensity>=THRESH) {  //Above or equal

          aboveThresh=true;

          sum_xfx+=time*intensity;
          sum_x+=time;  //Store the first time entry
          ctr+=1;
          if (rowBeginSection<0) rowBeginSection=i;

          //println(ctr,sum_x,sum_xfx);
        } else {

          //If finish a section above threshold, calculate peak follow by reseting fields
          if (aboveThresh==true) {

            //Calculating...        
            float intPeak=sum_xfx/sum_x;  
            float timePeak=getTimeEntry(rowBeginSection, intPeak, ctr); //sum_x/ctr;
            PVector pt = new PVector(timePeak, intPeak);
            timePeakPair.add(pt);        
            //println("CALC: ", ctr, timePeak, intPeak);

            //Reseting...
            sum_xfx=0;
            sum_x=0;
            ctr=0;
            rowBeginSection=-1;
            aboveThresh=false;
          }
        }
      }

`

kfrajer

It extracts peaks from data. It assumes you have a flat blackground, data noise is not an issue and your peaks are gaussian in nature (well, I also make sure it can detect single points above the threshold. It is a very simple algorithm to extract peaks based on your data.

The algorithm has two parts. It scans the data from left to right. Every time the data goes above the threshold [Line 1], the algorithm activates and perform some sums and data retention [Line 5-7]. As soon as the data goes below threshold[11], the algorithm deactivates and performs the peak calculation[17,18] before it resets its fields[23] for the next peak. Peak detection is based on a centroid averaging[17]. After I find the average max intensity, I run a third algorithm[18] (not robust but acceptable) to find the time associated to this peak.

Kf

ermina

Thank you..After a long time of study i managed to understand...Two last questions i want to put this

Max-peak-rate = numberOfPeaks / (endTimeDataSet - startTimeDataSet)

on the code...Which is the command that takes the endTimeDataSet, that can recognise and exports the last value of timeData??? Second, if i want to calculate only the number of the peaks, is all this code necessary or can i remove some lines??

kfrajer

Which is the command that takes the endTimeDataSet, that can recognise and exports the last value of timeData

There is no command. When you process your data, you have a data that is a time series. The first entry is the beginning and the last entry is the end of your time series, thus the begin and end times of your data set.

if i want to calculate only the number of the peaks

You can remove line 18 and the associated function. Then you need to replace the array of vectors for an array of floats to store only the peak intensity and not the time-peak value pairs.

The code could be simplify by only counting the number of times a data set goes above the threshold. This approach works if you assume you don't have multiple peaks in a region that is above the threshold.

Kf

ermina

There is no command. When you process your data, you have a data that is a time series. The first entry is the beginning and the last entry is the end of your time series, thus the begin and end times of your data set.

If i load differnet datasets and i dont know the end time is there a command that can find the end time or the last value of the column of time in csv table??

Also the problem is that i have multiple peaks in a region that is above the threshold.

kfrajer

If i load differnet datasets and i dont know the end time is there a command that can find the end time or the last value of the column

You answer your question yourself. It is the last data row in your table. For instance:

for (int row = 0; row < table.getRowCount(); row++) {

In the above line, your loop access all the data in the table. To access the last point you could use int time = table.getInt(table.getRowCount()-1, COL_TIME);

---

Also the problem is that i have multiple peaks in a region that is above the threshold.

This is what I wanted to make clear in my prev posts: the algorithm I provided is based on an assumption that there is single peak per region, which is extracted based on the selected Threshold. If that is not the case, then you need to find another algorithm. You can do a google search for "multiple peak detection" algorithm and you will get some ideas, or at least, what to consider in order to choose a proper algorithm suitable to your data set.

Kf

Chrisir

I hope this is solved

There is a new forum now

ermina

I have some mini problems but i think i will solve them..Thank you all of you for your help..If i stuck again i will ask for your opinions in the new forum..Thank you again very much...

Chrisir

;-)