bool Camera_SSPIAGClass::Capture(int duration, usImage& img, int options, const wxRect& subframe) { // Only does full frames still static int last_dur = 0; static int last_gain = 60; unsigned char *bptr; unsigned short *dptr; int x,y; int xsize = FullSize.GetWidth(); int ysize = FullSize.GetHeight(); // bool firstimg = true; if (img.Init(FullSize)) { DisconnectWithAlert(CAPT_FAIL_MEMORY); return true; } if (duration != last_dur) { Q5V_SetLongExpTime(duration); last_dur = duration; } else if (GuideCameraGain != last_gain) { Q5V_SetQHY5VGlobalGain(GuideCameraGain * 63 / 100); last_gain = GuideCameraGain; // Q5V_GetFullSizeImage(RawBuffer); } bptr = RawBuffer; Q5V_GetFullSizeImage(bptr); // Load and crop from the 800 x 525 image that came in dptr = img.ImageData; for (y=0; y<ysize; y++) { bptr = RawBuffer + 800*(y+4) + 47; for (x=0; x<xsize; x++, bptr++, dptr++) { // CAN SPEED THIS UP *dptr=(unsigned short) *bptr; } } if (options & CAPTURE_SUBTRACT_DARK) SubtractDark(img); // Do quick L recon to remove bayer array if (options & CAPTURE_RECON) QuickLRecon(img); return false; }
bool Camera_OpticstarPL130Class::Capture(int duration, usImage& img, int options, const wxRect& subframe) { bool still_going = true; int mode = 3 * (int) Color; if (img.Init(FullSize)) { DisconnectWithAlert(CAPT_FAIL_MEMORY); return true; } if (OSPL130_Capture(mode,duration)) { pFrame->Alert(_("Cannot start exposure")); return true; } if (duration > 100) { wxMilliSleep(duration - 100); // wait until near end of exposure, nicely wxGetApp().Yield(); // if (Abort) { // MeadeCam->AbortImage(); // return true; // } } while (still_going) { // wait for image to finish and d/l wxMilliSleep(20); OSPL130_IsExposing(&still_going); wxGetApp().Yield(); } // Download OSPL130_GetRawImage(0,0,FullSize.GetWidth(),FullSize.GetHeight(), (void *) img.ImageData); unsigned short *dataptr; dataptr = img.ImageData; // byte swap if (options & CAPTURE_SUBTRACT_DARK) SubtractDark(img); if (Color && (options & CAPTURE_RECON)) QuickLRecon(img); return false; }
bool WorkerThread::HandleExpose(MyFrame::EXPOSE_REQUEST *req) { bool bError = false; try { if (WorkerThread::MilliSleep(m_pFrame->GetTimeLapse(), INT_ANY)) { throw ERROR_INFO("Time lapse interrupted"); } if (pCamera->HasNonGuiCapture()) { Debug.Write(wxString::Format("Handling exposure in thread, d=%d o=%x r=(%d,%d,%d,%d)\n", req->exposureDuration, req->options, req->subframe.x, req->subframe.y, req->subframe.width, req->subframe.height)); if (GuideCamera::Capture(pCamera, req->exposureDuration, *req->pImage, req->options, req->subframe)) { throw ERROR_INFO("Capture failed"); } } else { Debug.Write(wxString::Format("Handling exposure in myFrame, d=%d o=%x r=(%d,%d,%d,%d)\n", req->exposureDuration, req->options, req->subframe.x, req->subframe.y, req->subframe.width, req->subframe.height)); wxSemaphore semaphore; req->pSemaphore = &semaphore; wxCommandEvent evt(REQUEST_EXPOSURE_EVENT, GetId()); evt.SetClientData(req); wxQueueEvent(m_pFrame, evt.Clone()); // wait for the request to complete req->pSemaphore->Wait(); bError = req->error; req->pSemaphore = NULL; } Debug.AddLine("Exposure complete"); if (!bError) { switch (m_pFrame->GetNoiseReductionMethod()) { case NR_NONE: break; case NR_2x2MEAN: QuickLRecon(*req->pImage); break; case NR_3x3MEDIAN: Median3(*req->pImage); break; } req->pImage->CalcStats(); } } catch (wxString Msg) { POSSIBLY_UNUSED(Msg); bError = true; } return bError; }
bool Camera_QHY::Capture(int duration, usImage& img, int options, const wxRect& subframe) { bool useSubframe = UseSubframes && !subframe.IsEmpty(); if (Binning != m_curBin) { FullSize = wxSize(m_maxSize.GetX() / Binning, m_maxSize.GetY() / Binning); m_curBin = Binning; useSubframe = false; // subframe may be out of bounds now } if (img.Init(FullSize)) { DisconnectWithAlert(CAPT_FAIL_MEMORY); return true; } wxRect frame = useSubframe ? subframe : wxRect(FullSize); if (useSubframe) img.Clear(); wxRect roi; if (useSubframe) { // Use a larger ROI around the subframe to avoid changing the ROI as the centroid // wobbles around. Changing the ROI introduces a lag of several seconds. // This also satifies the constraint that ROI width and height must be multiples of 4. enum { PAD = 1 << 5 }; roi.SetLeft(round_down(subframe.GetLeft(), PAD)); roi.SetRight(round_up(subframe.GetRight() + 1, PAD) - 1); roi.SetTop(round_down(subframe.GetTop(), PAD)); roi.SetBottom(round_up(subframe.GetBottom() + 1, PAD) - 1); } else { roi = frame; } uint32_t ret = QHYCCD_ERROR; // lzr from QHY says this needs to be set for every exposure ret = SetQHYCCDBinMode(m_camhandle, Binning, Binning); if (ret != QHYCCD_SUCCESS) { Debug.Write(wxString::Format("SetQHYCCDBinMode failed! ret = %d\n", (int)ret)); } if (m_roi != roi) { // when roi changes, must call this ret = CancelQHYCCDExposingAndReadout(m_camhandle); if (ret == QHYCCD_SUCCESS) { Debug.Write("CancelQHYCCDExposingAndReadout success\n"); } else { Debug.Write("CancelQHYCCDExposingAndReadout failed\n"); } ret = SetQHYCCDResolution(m_camhandle, roi.GetLeft(), roi.GetTop(), roi.GetWidth(), roi.GetHeight()); if (ret == QHYCCD_SUCCESS) { m_roi = roi; } else { Debug.Write(wxString::Format("SetQHYCCDResolution(%d,%d,%d,%d) failed! ret = %d\n", roi.GetLeft(), roi.GetTop(), roi.GetWidth(), roi.GetHeight(), (int)ret)); } } if (duration != m_curExposure) { ret = SetQHYCCDParam(m_camhandle, CONTROL_EXPOSURE, duration * 1000.0); // QHY duration is usec if (ret == QHYCCD_SUCCESS) { m_curExposure = duration; } else { Debug.Write(wxString::Format("QHY set exposure ret %d\n", (int)ret)); pFrame->Alert(_("Failed to set camera exposure")); } } if (GuideCameraGain != m_curGain) { double gain = m_gainMin + GuideCameraGain * (m_gainMax - m_gainMin) / 100.0; gain = floor(gain / m_gainStep) * m_gainStep; Debug.Write(wxString::Format("QHY set gain %g (%g..%g incr %g)\n", gain, m_gainMin, m_gainMax, m_gainStep)); ret = SetQHYCCDParam(m_camhandle, CONTROL_GAIN, gain); if (ret == QHYCCD_SUCCESS) { m_curGain = GuideCameraGain; } else { Debug.Write(wxString::Format("QHY set gain ret %d\n", (int)ret)); pFrame->Alert(_("Failed to set camera gain")); } } ret = ExpQHYCCDSingleFrame(m_camhandle); if (ret == QHYCCD_ERROR) { Debug.Write(wxString::Format("QHY exp single frame ret %d\n", (int)ret)); DisconnectWithAlert(_("QHY exposure failed"), NO_RECONNECT); return true; } if (ret == QHYCCD_SUCCESS) { Debug.Write(wxString::Format("QHY: 200ms delay needed\n")); WorkerThread::MilliSleep(200); } if (ret == QHYCCD_READ_DIRECTLY) { //Debug.Write("QHYCCD_READ_DIRECTLY\n"); } uint32_t w, h, bpp, channels; ret = GetQHYCCDSingleFrame(m_camhandle, &w, &h, &bpp, &channels, RawBuffer); if (ret != QHYCCD_SUCCESS || (bpp != 8 && bpp != 16)) { Debug.Write(wxString::Format("QHY get single frame ret %d bpp %u\n", ret, bpp)); // users report that reconnecting the camera after this failure allows // them to resume guiding so we'll try to reconnect automatically DisconnectWithAlert(_("QHY get frame failed"), RECONNECT); return true; } if (useSubframe) { img.Subframe = frame; int xofs = subframe.GetLeft() - roi.GetLeft(); int yofs = subframe.GetTop() - roi.GetTop(); int dxr = w - frame.width - xofs; if (bpp == 8) { const unsigned char *src = RawBuffer + yofs * w; unsigned short *dst = img.ImageData + frame.GetTop() * FullSize.GetWidth() + frame.GetLeft(); for (int y = 0; y < frame.height; y++) { unsigned short *d = dst; src += xofs; for (int x = 0; x < frame.width; x++) *d++ = (unsigned short) *src++; src += dxr; dst += FullSize.GetWidth(); } } else // bpp == 16 { const unsigned short *src = (const unsigned short *) RawBuffer + yofs * w; unsigned short *dst = img.ImageData + frame.GetTop() * FullSize.GetWidth() + frame.GetLeft(); for (int y = 0; y < frame.height; y++) { src += xofs; memcpy(dst, src, frame.width * sizeof(unsigned short)); src += frame.width + dxr; dst += FullSize.GetWidth(); } } } else { if (bpp == 8) { const unsigned char *src = RawBuffer; unsigned short *dst = img.ImageData; for (int y = 0; y < h; y++) { for (int x = 0; x < w; x++) { *dst++ = (unsigned short) *src++; } } } else // bpp == 16 { memcpy(img.ImageData, RawBuffer, w * h * sizeof(unsigned short)); } } if (options & CAPTURE_SUBTRACT_DARK) SubtractDark(img); if (Color && Binning == 1 && (options & CAPTURE_RECON)) QuickLRecon(img); return false; }
bool Camera_DSIClass::Capture(int duration, usImage& img, int options, const wxRect& subframe) { MeadeCam->SetGain((unsigned int) (GuideCameraGain * 63 / 100)); MeadeCam->SetExposureTime(duration); if (img.Init(MeadeCam->GetWidth(), MeadeCam->GetHeight())) { DisconnectWithAlert(CAPT_FAIL_MEMORY); return true; } bool retval = MeadeCam->GetImage(img.ImageData, true); if (!retval) return true; // The AbortImage method does not appear to work with the DSI camera. If abort is called and the thread is terminated, the // pending image is still downloaded and PHD2 will crash #if AbortActuallyWorks CameraWatchdog watchdog(duration, GetTimeoutMs()); // wait for image to finish and d/l while (!MeadeCam->ImageReady) { wxMilliSleep(20); if (WorkerThread::InterruptRequested()) { MeadeCam->AbortImage(); return true; } if (watchdog.Expired()) { MeadeCam->AbortImage(); DisconnectWithAlert(CAPT_FAIL_TIMEOUT); return true; } } #else // handle the pending image download, regardless // We also need to prevent the thread from being killed when phd2 is closed WorkerThreadKillGuard _guard; if (duration > 100) { wxMilliSleep(duration - 100); // wait until near end of exposure, nicely } bool still_going = true; while (still_going) { // wait for image to finish and d/l wxMilliSleep(20); still_going = !(MeadeCam->ImageReady); } #endif // end of waiting for the image if (options & CAPTURE_SUBTRACT_DARK) SubtractDark(img); if (options & CAPTURE_RECON) { if (MeadeCam->IsColor) QuickLRecon(img); if (MeadeCam->IsDsiII) SquarePixels(img, 8.6, 8.3); else if (!MeadeCam->IsDsiIII) // Original DSI SquarePixels(img, 9.6, 7.5); } return false; }
bool Camera_ASCOMLateClass::Capture(int duration, usImage& img, int options, const wxRect& subframeArg) { bool retval = false; bool takeSubframe = UseSubframes; wxRect subframe(subframeArg); if (subframe.width <= 0 || subframe.height <= 0) { takeSubframe = false; } bool binning_changed = false; if (Binning != m_curBin) { FullSize = wxSize(m_maxSize.x / Binning, m_maxSize.y / Binning); binning_changed = true; } // Program the size if (!takeSubframe) { subframe = wxRect(0, 0, FullSize.GetWidth(), FullSize.GetHeight()); } if (img.Init(FullSize)) { pFrame->Alert(_("Cannot allocate memory to download image from camera")); return true; } GITObjRef cam(m_gitEntry); EXCEPINFO excep; if (binning_changed) { if (ASCOM_SetBin(cam.IDisp(), Binning, &excep)) { pFrame->Alert(_("The ASCOM camera failed to set binning. See the debug log for more information.")); return true; } m_curBin = Binning; } if (subframe != m_roi) { ASCOM_SetROI(cam.IDisp(), subframe, &excep); m_roi = subframe; } bool takeDark = HasShutter && ShutterClosed; // Start the exposure if (ASCOM_StartExposure(cam.IDisp(), (double)duration / 1000.0, takeDark, &excep)) { Debug.AddLine(ExcepMsg("ASCOM_StartExposure failed", excep)); pFrame->Alert(ExcepMsg(_("ASCOM error -- Cannot start exposure with given parameters"), excep)); return true; } CameraWatchdog watchdog(duration, GetTimeoutMs()); if (duration > 100) { // wait until near end of exposure if (WorkerThread::MilliSleep(duration - 100, WorkerThread::INT_ANY) && (WorkerThread::TerminateRequested() || AbortExposure())) { return true; } } while (true) // wait for image to finish and d/l { wxMilliSleep(20); bool ready; EXCEPINFO excep; if (ASCOM_ImageReady(cam.IDisp(), &ready, &excep)) { Debug.AddLine(ExcepMsg("ASCOM_ImageReady failed", excep)); pFrame->Alert(ExcepMsg(_("Exception thrown polling camera"), excep)); return true; } if (ready) break; if (WorkerThread::InterruptRequested() && (WorkerThread::TerminateRequested() || AbortExposure())) { return true; } if (watchdog.Expired()) { DisconnectWithAlert(CAPT_FAIL_TIMEOUT); return true; } } // Get the image if (ASCOM_Image(cam.IDisp(), img, takeSubframe, subframe, &excep)) { Debug.AddLine(ExcepMsg(_T("ASCOM_Image failed"), excep)); pFrame->Alert(ExcepMsg(_("Error reading image"), excep)); return true; } if (options & CAPTURE_SUBTRACT_DARK) SubtractDark(img); if (Color && Binning == 1 && (options & CAPTURE_RECON)) QuickLRecon(img); return false; }