PROG Second attempt to fix the race condition in findimageoverlaps, added more...

        }

      }

      p_lonLatOverlapsMutex.lock();

      p_lonLatOverlaps.push_back(CreateNewOverlap(sns.serialNumber(i), mp));

      p_lonLatOverlapsMutex.unlock();

      if (mp) {

        delete mp;

    // Create one ImageOverlap for each image sn

    for (unsigned int i = 0; i < sns.size(); ++i) {

      p_lonLatOverlapsMutex.lock();

      p_lonLatOverlaps.push_back(CreateNewOverlap(sns[i], polygons[i]));

      p_lonLatOverlapsMutex.unlock();

    }

    // Despikes the polygons from the Serial Numbers prior to overlap determination

      inStream.open(file.c_str(), fstream::in | fstream::binary);

      while (!inStream.eof()) {

        p_lonLatOverlapsMutex.lock();

        p_lonLatOverlaps.push_back(new ImageOverlap(inStream));

        p_lonLatOverlapsMutex.unlock();

      }

      inStream.close();

        // Insert could cause a reallocation of the overlap list, so lock it with

        //   the writing code so that we don't conflict

        QMutexLocker locker(&p_lonLatOverlapsMutex);

        p_lonLatOverlapsMutex.lock();

        p_lonLatOverlaps.insert(p_lonLatOverlaps.begin() + position, imageOverlap);

        p_lonLatOverlapsMutex.unlock();

      }

      success = true;

      static bool overlapWritten = false;

      for (int overlap = p_writtenSoFar; !failed && overlap <= p_calculatedSoFar; overlap++) {

        // Let's not try anything during a possible reallocate

        QMutexLocker locker(&p_lonLatOverlapsMutex);

        p_lonLatOverlapsMutex.lock();

        if (p_lonLatOverlaps.size() == 0) {

          noOverlaps = true;

            p_writtenSoFar ++;                

          }

        }

        p_lonLatOverlapsMutex.unlock();

      }

      failed |= outStream.fail();

      outStream.close();

          // Check to see if the two poygons are equivalent.

          // If they are, then we can get rid of one of them

          if (PolygonTools::Equal(poly1, poly2)) {

            p_lonLatOverlapsMutex.lock();

            AddSerialNumbers(p_lonLatOverlaps[outside], p_lonLatOverlaps[inside]);

            p_lonLatOverlaps.erase(p_lonLatOverlaps.begin() + inside);

            p_lonLatOverlapsMutex.unlock();

            inside --;

            continue;

          }

          // We can get empty polygons in our list sometimes; try to avoid extra processing

          if (poly2->isEmpty() || poly2->getArea() < 1.0e-14) {

            p_lonLatOverlapsMutex.lock();

            p_lonLatOverlaps.erase(p_lonLatOverlaps.begin() + inside);

            p_lonLatOverlapsMutex.unlock();

            inside --;      

            continue;

          }

              if (poly1->getArea() > poly2->getArea()) {

                error += " The first polygon will be removed.";

                HandleError(e, snlist, error, inside, outside);

                p_lonLatOverlapsMutex.lock();

                p_lonLatOverlaps.erase(p_lonLatOverlaps.begin() + inside);

                p_lonLatOverlapsMutex.unlock();

                inside --;

              }

              else {

                error += " The second polygon will be removed.";

                HandleError(e, snlist, error, inside, outside);

                p_lonLatOverlapsMutex.lock();

                p_lonLatOverlaps.erase(p_lonLatOverlaps.begin() + outside);

                p_lonLatOverlapsMutex.unlock();

                inside = outside;

              }

            }

              error += " Both polygons will be removed to prevent the "

                       "possibility of double counted areas.";

              HandleError(e, snlist, error, inside, outside);

              p_lonLatOverlapsMutex.lock();

              p_lonLatOverlaps.erase(p_lonLatOverlaps.begin() + inside);

              p_lonLatOverlaps.erase(p_lonLatOverlaps.begin() + outside);

              p_lonLatOverlapsMutex.unlock();

              inside = outside;

            }

              // Delete outside polygon directly and reset outside loop

              //   - current outside is thrown out!

              p_lonLatOverlapsMutex.lock();

              p_lonLatOverlaps.erase(p_lonLatOverlaps.begin() + outside);

              p_lonLatOverlapsMutex.unlock();

              inside = outside;

              continue;

            }

                                     "The second polygon will be removed.", inside, outside);

              // Delete inside polygon directly and process next inside

              p_lonLatOverlapsMutex.lock();

              p_lonLatOverlaps.erase(p_lonLatOverlaps.begin() + inside);

              p_lonLatOverlapsMutex.unlock();

              inside --;

              continue;

            }

    // Do not write empty overlap files

    if (foundOverlap == false) {

      p_lonLatOverlapsMutex.lock();

      p_lonLatOverlaps.clear();

      p_lonLatOverlapsMutex.unlock();

    }

    // unblock the writing process