[Java][C] Probleem met het lezen van een .csv file

[RabbitHeart]

Hallo iedereen!

Als mijn java programma een .csv file probeert te lezen gooit hij een NullPointerException.

Mijn programma werkt als volgende:

1. Set data wordt geanalyseerd door een c programma, gebruikt in mijn java programma door JNA. Resultaten van deze actie worden opgeslagen als 1.csv.

2. Mijn java class opent 1.csv en analyseert die resultaten.

Stap 1 en 2 werken prima los van elkaar, maar als ik ze achter elkaar wil uitvoeren gooit hij dus die exception. Wat zie ik over het hoofd . Ik vermoed zelf dat het iets te maken heeft met het niet goed sluiten van 1.csv, maar ik heb fclose al in mijn c code staan. Ik ben zelf helemaal niet thuis in C.

Alvast bedankt voor jullie hulp .

[Creepy]

Dus je bent al stap voor stap door je (java) geen heen gelopen met de debugger en toen zag je precies wat er NULL was, wat was dat dan precies? En geef dan ook gelijk de relevante code even, want nu kunnen we je echt absoluut niet helpen.

[YopY]

Tip: Als Java een NPE gooit, geeft hij precies aan op welke regel code de nullpointer zich voordeed. Vanaf daar is het debuggen.

[RabbitHeart]

Hier gooit hij die error:

Java:

read_data(1.csv);

Dit is read_data:

Java:

    private static void read_data(String fname)
            throws IOException {

        nFeatures = 0; //Reset for next block

        /*
         * Count number of lines - makes it neater in the long run
         */
        FileReader frx = new FileReader("results_tracker/x" + fname);
        BufferedReader bfx = new BufferedReader(frx);
        while (bfx.readLine() != null) {
            nFeatures++;
        }

        /*
         * Reset
         */
        frx = new FileReader("results_tracker/x" + fname);
        bfx = new BufferedReader(frx);

        FileReader fry = new FileReader("results_tracker/y" + fname);
        BufferedReader bfy = new BufferedReader(fry);

        /*
         * Now set up array and read in each line
         */
        data = new Path[nFeatures];

        String xin;
        String yin;
        int i = 0;

        while ((xin = bfx.readLine()) != null && (yin = bfy.readLine()) != null) {
            try {
                data[i] = new Path(xin, yin);
            } catch (NumberFormatException e) {
                System.out.println("(CSV error: skipping broken Path)");
                nFeatures--;

                Path[] temp = new Path[nFeatures];

                for (int j = 0; j < i; j++) {
                    temp[j] = data[j];
                }

                data = temp;
                i--; //Count one back
            }
            i++;
        }
    }

Dit is mijn c code:

C:

         FILE *xvis_file;
        char xvis_string[50];
        sprintf(xvis_string, "results_tracker/x%cvis_block_%08d.csv", footage, i);

        FILE *yvis_file;
        char yvis_string[50];
        sprintf(yvis_string, "results_tracker/y%cvis_block_%08d.csv", footage, i);

        xvis_file = fopen(xvis_string, "w");
        yvis_file = fopen(yvis_string, "w");

        /*Print out all the complete paths*/
        for (j = 0; j < nFeatures; j++) {

            if (complete[j] == 1) {

                KLT_FeatureHistory fh;
                fh = KLTCreateFeatureHistory(nBlock);
                KLTExtractFeatureHistory(fh, ft, j);

                for (k = 1; k < nBlock; k++) {

                    double xo = fh->feature[k]->x;
                    double yo = fh->feature[k]->y;
                    double val = fh->feature[k]->val;

                    /*
                                        if (val != 0 && k > 0)printf("ERROR ERROR ERROR ERROR\n");
                     */

                    fprintf(xvis_file, "%f", xo);
                    fprintf(yvis_file, "%f", yo);

                    if (k != nBlock - 1) {
                        fprintf(xvis_file, ",");
                        fprintf(yvis_file, ",");
                    }

                }

                fprintf(xvis_file, "\n");
                fprintf(yvis_file, "\n");


            }
        }

        /*End printing paths for analysis*/
        fclose(xvis_file);
        fclose(yvis_file);
        nTrace += (nBlock - 1);
    } 

Los van elkaar werkt het perfect. Dus als ik alleen stap 1 uitvoer (met 2 in comments), en vervolgens stap 2 met 1 in comments dan werkt het. Terwijl de .csv file identiek is.

[Verwijderd]

Stacktrace would be nice

[RabbitHeart]

Exception in thread "main" java.lang.NullPointerException
at AJMParticleFilter.LDB.LDB(LDB.java:87)
at Test.main(Test.java:35)

Java:

package AJMParticleFilter;


import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.StringTokenizer;
import java.util.Vector;

public class LDB {

    private static Path[] data; //Array of path objects
    private static int nFeatures;


    /*
     * Start Main
     */
    public void LDB(String s, double mindirchange, double minsd, double radiuss, double pfspr, double pfmv, int waggle, int start, int printvid) 
            throws IOException {

        /*
         * Get footage & footage parameters
         */

        String footage = s;
        
        BufferedReader br = new BufferedReader(new FileReader(String.format("footage_%s.csv", footage)));
        StringTokenizer st = new StringTokenizer(br.readLine(), ",");
        int fImage = new Integer(st.nextToken()).intValue();
        int nBlocks = new Integer(st.nextToken()).intValue();
        int nBlock = new Integer(st.nextToken()).intValue();
        int ppm_width = new Integer(st.nextToken()).intValue();
        int ppm_height = new Integer(st.nextToken()).intValue();

        /*
         * Initialisation and PF Arguments
         */
        double min_dir_change = new Double(mindirchange).doubleValue();
        double min_sd = new Double(minsd).doubleValue();

        double radius = new Double(radiuss).doubleValue();
        double pf_rad = radius;
        double pf_spr = new Double(pfspr).doubleValue();
        double pf_mv = new Double(pfmv).doubleValue();
        int nWaggle = new Integer(waggle).intValue(); //Number of paths which constitute a waggle
        int nStart = new Integer(start).intValue();    //Number of paths to start a Particle Filter

        /*
         * Output Option
         */
        int print_videos = new Integer(printvid).intValue();
        System.out.println("Print videos: "+print_videos);

        /*
         * Constants
         */
        final int xres = 1;
        final int yres = 1;
        final int np = 50;
        final int nContinue = 1;
        final int metric = 1;


        /*
         * Object controls Particle Filters
         */
        SMC sm = new SMC();

        for (int k = fImage; k < fImage + nBlock * nBlocks - (nBlocks + 1); k += nBlock - 1) {

            /*
             * STEP 1: GENERATE FEATURE SPACE AT TIME K
             */
            System.out.println(String.format("block %d...", k));

            System.out.println(String.format("..reading block %d", k));
            read_data(String.format("%svis_block_%08d.csv", footage, k));

            System.out.println(String.format("..classifying block %d, (%d)", k, nFeatures));
            Vector<Path> v_feat = new Vector<Path>(0, 1);

            /*
             * Generate Feature Space for this block
             */
            for (int i = 0; i < nFeatures; i++) {
                data[i].statx();
                data[i].staty();
                data[i].setstart(k);

                if (data[i].dir_change(i) > min_dir_change && Math.max(data[i].stdx, data[i].stdy) > min_sd) {
                    v_feat.add(data[i]);
                }

            }


            /*
             * STEP 2: SUBSUME FEATURES INTO EXISTING PARTICLE FILTERS AT TIME K
             */
            System.out.println(String.format("..compiling block %d, (%d)", k, v_feat.size()));
            v_feat = sm.compile_features(v_feat, nContinue);


            /*
             * STEP 3: INITIALSE PARTICLE FILTERS WITH FEATURES AT TIME K
             */
            Store s_counter = new Store();
            System.out.println(String.format("..grouping block %d, (%d)", k, v_feat.size()));

            /*
             * Perform grouping for that block
             */
            for (int x = 0; x < ppm_width; x += xres) {
                for (int y = 0; y < ppm_height; y += yres) {

                    Counter c = new Counter((double) x, (double) y, radius);

                    for (int i = 0; i < v_feat.size(); i++) {
                        Path p_temp = v_feat.get(i);
                        p_temp.statx();
                        p_temp.staty();
                        if (Distance.distance(metric, p_temp.meanx, p_temp.meany, c.getx(), c.gety()) < radius) {
                            c.inc(p_temp);
                        }
                    }

                    if (c.getn() > 0) //Threshold to speed things up
                    {
                        s_counter.add_counter(c, radius, metric);
                    }

                }
            }

            System.out.println(String.format("..initialising block %d, (%d)", k, v_feat.size()));
            sm.add_store(s_counter, np, pf_rad, pf_spr, pf_mv, nStart);
            sm.sort_pfs();


            /*
             * STEP 4: MEASURE ALL PARTICLE FILTERS
             */
            System.out.println(String.format("..measuring block %d, (%d)", k, v_feat.size()));
            sm.measure();


            /*
             * STEP 5: ADVANCE ALL PARTICLE FILTERS
             */
            System.out.println(String.format("..advancing block %d, (%d)", k, v_feat.size()));
            sm.advance();

            Results print = new Results(sm, nWaggle);
//            print.print_image(String.format("000000"+k+".ppm", footage), ppm_width, ppm_height);
        }
        /*
         * End block
         */

        sm.end(); //Wrap up existing particle filters
        sm.final_sort(); //Sort in order of total number of particles 

        /*
         * Process and output results
         */
        Results r = new Results(sm, nWaggle); //Create Results object from SMC object

        r.print_image(String.format("final_results_%s.ppm", footage), ppm_width, ppm_height);
        r.print_file(String.format("final_results_%s.csv", footage));

        if (print_videos == 1) {
            r.print_videos(fImage, nBlocks, nBlock, footage, ppm_width, ppm_height);
        }


    }
    /*
     * End main
     */

    /*
     * Read csv files containg Complete Paths
     */
    private static void read_data(String fname)
            throws IOException {

        nFeatures = 0; //Reset for next block

        /*
         * Count number of lines - makes it neater in the long run
         */
        FileReader frx = new FileReader("results_tracker/x" + fname);
        BufferedReader bfx = new BufferedReader(frx);
        while (bfx.readLine() != null) {
            nFeatures++;
        }

        /*
         * Reset
         */
        frx = new FileReader("results_tracker/x" + fname);
        bfx = new BufferedReader(frx);

        FileReader fry = new FileReader("results_tracker/y" + fname);
        BufferedReader bfy = new BufferedReader(fry);

        /*
         * Now set up array and read in each line
         */
        data = new Path[nFeatures];

        String xin;
        String yin;
        int i = 0;

        while ((xin = bfx.readLine()) != null && (yin = bfy.readLine()) != null) {
            try {
                data[i] = new Path(xin, yin);
            } catch (NumberFormatException e) {
                System.out.println("(CSV error: skipping broken Path)");
                nFeatures--;

                Path[] temp = new Path[nFeatures];
                System.arraycopy(data, 0, temp, 0, i);

                data = temp;
                i--; //Count one back
            }
            i++;
        }
    }
    /*
     * End read_data
     */
}

Sorry voor de lange code. Ik heb net zitten debuggen maar alles lijkt gewoon in orde!!

[RabbitHeart]

Ik heb geen idee waar het aan ligt .

Volgens mij ligt het niet aan de java code, ook niet aan de c code. Alles doet het gewoon als ik stap 1 oversla (en de resultaten van de vorige run gebruik). Het is de combinatie van beiden. Heeft iemand nog een goede tip om dit te debuggen/omzeilen?

[Jegorex]

Heb je al wel gekeken wat er in de stacktrace staat?

code:

at AJMParticleFilter.LDB.LDB(LDB.java:87)

Dit is regel 87:

Java:

data[ i ].statx();

i is een integer, die kan geen NULL zijn. i bevind zich ook binnen het bereik van de array, anders zou je een index out of bounds exception krijgen. Je kunt dus concluderen dat data[ i ] de waarde NULL heeft.
Waarom is data[ i ] NULL?
Waar word de data array aangemaakt en gevuld?

[Lone Gunman]

Misschien is de dataset nog niet compleet naar disk weggeschreven door het OS? Je mag iig niet aannemen dat de data na een fclose() op disk staat en direct gelezen kan worden door andere programma's (in dit geval je java app).

Verder heb je nogal wat 'dubieuze' constructies in je code, onder andere in je read_data method.
Waarom eerst inlezen hoeveel regels/features de csv heeft en daarna de file opnieuw openen om in te lezen? Dit zou bv problemen kunnen geven als de file tussen het twee keer openen verandert waardoor er meer regels/features zijn dan na het tellen, waardoor je array te klein is.
Waarom de rare constructie met System.arraycopy()? Als je arraylist/vector functionaliteit wilt, gebruik die dan gewoon .

Bovenstaande punten zouden de oorzaak kunnen zijn, alhoewel ik niet direct zie waar dit een npe zou kunnen veroorzaken.

Is het trouwens echt nodig om met csv files te werken tussen het c en java gedeelte? Ik weet niet hoe groot je dataset is, maar als je toch al JNA gebruikt dan zou ik de overdracht van de dataset ook met JNA doen. Dan loop je iig niet tegen de problemen aan die kunnen ontstaan als je files gebruikt.

[RabbitHeart]

Lone Gunman schreef op woensdag 02 mei 2012 @ 00:50:
Misschien is de dataset nog niet compleet naar disk weggeschreven door het OS? Je mag iig niet aannemen dat de data na een fclose() op disk staat en direct gelezen kan worden door andere programma's (in dit geval je java app).

Verder heb je nogal wat 'dubieuze' constructies in je code, onder andere in je read_data method.
Waarom eerst inlezen hoeveel regels/features de csv heeft en daarna de file opnieuw openen om in te lezen? Dit zou bv problemen kunnen geven als de file tussen het twee keer openen verandert waardoor er meer regels/features zijn dan na het tellen, waardoor je array te klein is.
Waarom de rare constructie met System.arraycopy()? Als je arraylist/vector functionaliteit wilt, gebruik die dan gewoon .

Bovenstaande punten zouden de oorzaak kunnen zijn, alhoewel ik niet direct zie waar dit een npe zou kunnen veroorzaken.

Is het trouwens echt nodig om met csv files te werken tussen het c en java gedeelte? Ik weet niet hoe groot je dataset is, maar als je toch al JNA gebruikt dan zou ik de overdracht van de dataset ook met JNA doen. Dan loop je iig niet tegen de problemen aan die kunnen ontstaan als je files gebruikt.

Bedankt voor jullie reacties! Er is echt teveel data om via JNA te laten gaan.

Ik ben nu aan het kijken met de debugger, bij lijn 87 zijn er geen rare variabelen die er in gaan. Xin en Yin zijn even groot, i = 0. Opencsv kan de files wel lezen en kopieren, dus kennelijk kunnen de files wel meteen worden gebruikt.

Dit is niet helemaal mijn eigen code (heb hem wel aangepast nu), dus excuses voor de rare dingen .

[Soultaker]

Lone Gunman schreef op woensdag 02 mei 2012 @ 00:50:
Misschien is de dataset nog niet compleet naar disk weggeschreven door het OS? Je mag iig niet aannemen dat de data na een fclose() op disk staat en direct gelezen kan worden door andere programma's (in dit geval je java app).

Niet per se op disk, maar je wag er wél vanuit gaan dat de data uit userspace buffers is geflushed en dat andere applicaties vanaf dat moment alle geschreven data kunnen lezen. (Of die data vanaf de schijf komt of vanuit de write cache van het OS maakt natuurlijk niet uit.)

Dit zou bv problemen kunnen geven als de file tussen het twee keer openen verandert waardoor er meer regels/features zijn dan na het tellen, waardoor je array te klein is.

Als het bestand geschreven wordt terwijl je 'm aan het lezen kan er natuurlijk van alles foutgaan. Het lijkt me logisch dat je daar niet vanuit gaat. (Los daarvan is het waarschijnlijk wel handiger om het bestand in één keer in te lezen als dat kan.)

[RabbitHeart]

Soultaker schreef op woensdag 02 mei 2012 @ 01:26:
[...]

Niet per se op disk, maar je wag er wél vanuit gaan dat de data uit userspace buffers is geflushed en dat andere applicaties vanaf dat moment alle geschreven data kunnen lezen. (Of die data vanaf de schijf komt of vanuit de write cache van het OS maakt natuurlijk niet uit.)


[...]

Als het bestand geschreven wordt terwijl je 'm aan het lezen kan er natuurlijk van alles foutgaan. Het lijkt me logisch dat je daar niet vanuit gaat. (Los daarvan is het waarschijnlijk wel handiger om het bestand in één keer in te lezen als dat kan.)

Data flushen? Zou dat het probleem kunnen zijn?

Edit: het ziet er naar uit dat het echt een probleem is met de bestanden. Java kan ze niet lezen als C er net mee bezig is geweest. Is er een manier om C die files definitief af te laten sluiten??

[ Voor 12% gewijzigd door RabbitHeart op 02-05-2012 01:57 ]

[RabbitHeart]

Het probleem is opgelost . Ik heb gewoon fflush en fclose toegevoegd aan het einde van mijn c code :-) .

[Reptile209]

Dan heb je het nu aan de C-kant 'opgelost' met iets dat je al had moeten doen: je files sluiten na gebruik . Kijk nu nog eens kritisch naar de delen in Java waarin je de file opent en uitleest: waarschijnlijk negeer je daar op dit moment ook al een fout die aangaf dat het openen van de file niet gelukt is? Test eens wat cases als niet-bestaande file, file die al gelocked is door een ander proces, enz (?), en vang die netjes op. Daar wordt je code alleen maar robuuster van.

[RabbitHeart]

Reptile209 schreef op woensdag 02 mei 2012 @ 06:37:
Dan heb je het nu aan de C-kant 'opgelost' met iets dat je al had moeten doen: je files sluiten na gebruik . Kijk nu nog eens kritisch naar de delen in Java waarin je de file opent en uitleest: waarschijnlijk negeer je daar op dit moment ook al een fout die aangaf dat het openen van de file niet gelukt is? Test eens wat cases als niet-bestaande file, file die al gelocked is door een ander proces, enz (?), en vang die netjes op. Daar wordt je code alleen maar robuuster van.

De c-files komen allemaal van iemand anders . Het is ook mijn fout, het was eerst de main method en die heb ik veranderd in een normale method. Ik kon voor deze opdracht echt 0,0 c, nu wel een beetje.

Mijn programma werkt trouwens .

[Soultaker]

Beetje raar verhaal, want volgens de TS fclose()de je het bestand al in C. Daarbij wordt al data geflushed, dus een extra fflush() zou niets uit moeten maken.

[ Voor 11% gewijzigd door Soultaker op 02-05-2012 08:52 ]