#include <sstream>
Image3DDequeUR::Image3DDequeUR() {
- this->m_GlobalPath = "/home/caceres/temporal/";
- this->m_CurrentUndoPos = -1;
- this->m_CurrentRedoPos = -1;
+ this->m_GlobalPath = "/home/pechan/temporal/";
+ this->m_CurrentURPos = -1;
}
//virtual
Image3DDequeUR::~Image3DDequeUR() {
this->CleanHardDisk();
}
//virtual
-void Image3DDequeUR::AddImageToUndoContainer(VTKImageDataPointerType img,
- ImageMManagerType* imMManager) {
- this->CleanUndoContainerFromIndex(this->m_CurrentUndoPos + 1);
+void Image3DDequeUR::AddImagesToURContainer(VTKImageDataPointerType imgUndo,
+ VTKImageDataPointerType imgRedo, ImageMManager* imMManager) {
+ this->CleanURContainerFromIndex(this->m_CurrentURPos + 1);
//Adding image
ImageInfoUR* imageInfo = new ImageInfoUR();
imageInfo->SetImageName(
- this->GetImageName(this->m_ImgUndoDeque.size(), true));
- imageInfo->SetImage(img);
+ this->GetImageName(this->m_ImgURDeque.size(), true));
+ imageInfo->SetImages(imgUndo, imgRedo);
imageInfo->SetImageMManager(imMManager);
//Adding to deque
- this->m_ImgUndoDeque.push_back(imageInfo);
- this->m_CurrentUndoPos = this->m_ImgUndoDeque.size() - 1;
+ this->m_ImgURDeque.push_back(imageInfo);
+ this->m_CurrentURPos = this->m_ImgURDeque.size() - 1;
//Managing memory
this->ManageMemory();
- //clean redo container
- this->CleanRedoContainer();
}
//virtual
ImageInfoUR* Image3DDequeUR::Undo() {
ImageInfoUR* imgRet = NULL;
- if ((this->m_ImgUndoDeque.size() > 0) && (this->m_CurrentUndoPos != -1)) {
- imgRet = this->m_ImgUndoDeque[m_CurrentUndoPos];
- this->m_CurrentUndoPos--;
+ if ((this->m_ImgURDeque.size() > 0) && (this->m_CurrentURPos != -1)) {
+ imgRet = this->m_ImgURDeque[m_CurrentURPos];
+ this->m_CurrentURPos--;
} //fi
return (imgRet);
}
-//virtual
-void Image3DDequeUR::AddImageToRedoContainer(VTKImageDataPointerType img,
- ImageMManagerType* imMManager) {
- //Adding image
- ImageInfoUR* imageInfo = new ImageInfoUR();
- imageInfo->SetImageName(
- this->GetImageName(this->m_ImgRedoDeque.size(), false));
- imageInfo->SetImage(img);
- imageInfo->SetImageMManager(imMManager);
- //Adding to deque
- this->m_ImgRedoDeque.push_back(imageInfo);
- this->m_CurrentRedoPos = this->m_ImgRedoDeque.size() - 1;
- //Managing memory
- this->ManageMemory();
-}
//virtual
ImageInfoUR* Image3DDequeUR::Redo() {
ImageInfoUR* imgRet = NULL;
- if ((this->m_ImgRedoDeque.size() > 0) && (this->m_CurrentRedoPos != -1)) {
- imgRet = this->m_ImgRedoDeque[m_CurrentRedoPos];
- this->m_CurrentRedoPos--;
- this->m_CurrentUndoPos++;
- } //fi
return (imgRet);
}
//virtual
-void Image3DDequeUR::CleanUndoContainerFromIndex(const int& index) {
+void Image3DDequeUR::CleanURContainerFromIndex(const int& index) {
int count = 0;
- for (unsigned int i = index; i < this->m_ImgUndoDeque.size(); i++) {
- this->m_ImgUndoDeque[i]->RemoveImageFromMemory(this->m_GlobalPath);
- this->m_ImgUndoDeque[i]->RemoveImageFromDisk(this->m_GlobalPath);
+ for (unsigned int i = index; i < this->m_ImgURDeque.size(); i++) {
+ this->m_ImgURDeque[i]->RemoveImagesFromMemory(this->m_GlobalPath);
+ this->m_ImgURDeque[i]->RemoveImagesFromDisk(this->m_GlobalPath);
count++;
}
for (int i = 0; i < count; i++) {
- this->m_ImgUndoDeque.pop_back();
+ this->m_ImgURDeque.pop_back();
} //rof
}
-//virtual
-void Image3DDequeUR::CleanRedoContainer() {
- for (unsigned int i = 0; i < this->m_ImgRedoDeque.size(); i++) {
- this->m_ImgRedoDeque[i]->RemoveImageFromMemory(this->m_GlobalPath);
- this->m_ImgRedoDeque[i]->RemoveImageFromDisk(this->m_GlobalPath);
- }
-}
-//virtual
-void Image3DDequeUR::CleanContainers() {
- for (unsigned int i = 0; i < this->m_ImgUndoDeque.size(); i++) {
- this->m_ImgUndoDeque[i]->RemoveImageFromMemory(this->m_GlobalPath);
- this->m_ImgUndoDeque[i]->RemoveImageFromDisk(this->m_GlobalPath);
- } //rof
- for (unsigned int i = 0; i < this->m_ImgRedoDeque.size(); i++) {
- this->m_ImgRedoDeque[i]->RemoveImageFromMemory(this->m_GlobalPath);
- this->m_ImgRedoDeque[i]->RemoveImageFromDisk(this->m_GlobalPath);
- } //rof
- this->m_ImgRedoDeque.clear();
- this->m_ImgUndoDeque.clear();
-}
//virtual
void Image3DDequeUR::ManageMemory() {
- for (int i = 0; (unsigned int) i < this->m_ImgUndoDeque.size(); i++) {
- if (this->m_ImgUndoDeque[i]->GetStatus()) {
- this->m_ImgUndoDeque[i]->RemoveImageFromMemory(this->m_GlobalPath);
+ for (int i = 0; (unsigned int) i < this->m_ImgURDeque.size(); i++) {
+ if (this->m_ImgURDeque[i]->GetStatus()) {
+ this->m_ImgURDeque[i]->RemoveImagesFromMemory(this->m_GlobalPath);
} //fi
} //rof
//Adding CurrentUndoPos to memory
- if ((this->m_CurrentUndoPos != -1)
- && !(this->m_ImgUndoDeque[this->m_CurrentUndoPos]->GetStatus())) {
- this->m_ImgUndoDeque[this->m_CurrentUndoPos]->LoadImageMHDToMemory(
- this->m_GlobalPath);
- }
- //The same for the redo queue
- for (int i = 0; (unsigned int) i < this->m_ImgRedoDeque.size(); i++) {
- if (this->m_ImgRedoDeque[i]->GetStatus()) {
- this->m_ImgRedoDeque[i]->RemoveImageFromMemory(this->m_GlobalPath);
- } //fi
- } //rof
- //Adding CurrentUndoPos to memory
- if ((this->m_CurrentRedoPos != -1)
- && !(this->m_ImgRedoDeque[this->m_CurrentRedoPos]->GetStatus())) {
- this->m_ImgRedoDeque[this->m_CurrentRedoPos]->LoadImageMHDToMemory(
+ if ((this->m_CurrentURPos != -1)
+ && !(this->m_ImgURDeque[this->m_CurrentURPos]->GetStatus())) {
+ this->m_ImgURDeque[this->m_CurrentURPos]->LoadImagesToMemory(
this->m_GlobalPath);
}
}
}
void Image3DDequeUR::CleanHardDisk() {
- for (unsigned int i = 0; i < this->m_ImgUndoDeque.size(); i++) {
- this->m_ImgUndoDeque[i]->RemoveImageFromDisk(this->m_GlobalPath);
+ for (unsigned int i = 0; i < this->m_ImgURDeque.size(); i++) {
+ this->m_ImgURDeque[i]->RemoveImagesFromDisk(this->m_GlobalPath);
}
}
}
std::stringstream ss; //create a stringstream
ss << pos; //add number to the stream
- StringType imgType;
- if (undo) {
- imgType = "undo";
- } else {
- imgType = "redo";
- }
- StringType imageName = this->m_IDImages + imgType + ss.str();
+ StringType imageName = this->m_IDImages + ss.str();
return (imageName);
}
public:
Image3DDequeUR();
virtual ~Image3DDequeUR();
+ virtual void AddImagesToURContainer(VTKImageDataPointerType imgUndo,
+ VTKImageDataPointerType imgRedo, ImageMManager* imMManager);
+ virtual void CleanURContainerFromIndex(const int& index);
+ virtual void ManageMemory();
+ virtual ImageInfoUR* Undo();
+ virtual ImageInfoUR* Redo();
void SetGlobalPath(const StringType& globalPath);
StringType GetGlobalPath();
StringType GetImageName(const int & pos, const bool& undo);
void CleanHardDisk();
- virtual void AddImageToUndoContainer(VTKImageDataPointerType img,
- ImageMManagerType* imMManager);
- virtual void AddImageToRedoContainer(VTKImageDataPointerType img,
- ImageMManagerType* imMManager);
- virtual void CleanUndoContainerFromIndex(const int& index);
- virtual void CleanRedoContainer( );
- virtual void CleanContainers();
- virtual void ManageMemory();
- virtual ImageInfoUR* Undo();
- virtual ImageInfoUR* Redo();
protected:
- ImageInfoDeque m_ImgUndoDeque;
- ImageInfoDeque m_ImgRedoDeque;
- int m_CurrentUndoPos;
- int m_CurrentRedoPos;
+ ImageInfoDeque m_ImgURDeque;
+ int m_CurrentURPos;
StringType m_GlobalPath;
StringType m_IDImages;
};
ImageDequeUR::~ImageDequeUR() {
}
-void ImageDequeUR::AddImageToUndoContainer(VTKImageDataPointerType img,
- ImageMManager* imManager) {
+void ImageDequeUR::AddImagesToURContainer(VTKImageDataPointerType imgUndo,
+ VTKImageDataPointerType imgRedo, ImageMManager* imMManager) {
}
-void ImageDequeUR::AddImageToRedoContainer(VTKImageDataPointerType img,
- ImageMManager* imMManager) {
-}
-void ImageDequeUR::CleanUndoContainerFromIndex(const int& index) {
-}
-void ImageDequeUR::CleanRedoContainer( ) {
-}
-void ImageDequeUR::CleanContainers() {
+void ImageDequeUR::CleanURContainerFromIndex(const int& index) {
}
public:
ImageDequeUR();
virtual ~ImageDequeUR();
- virtual void AddImageToUndoContainer(VTKImageDataPointerType img,
- ImageMManager* imMManager);
- virtual void AddImageToRedoContainer(VTKImageDataPointerType img,
- ImageMManager* imMManager);
- virtual void CleanUndoContainerFromIndex(const int& index);
- virtual void CleanRedoContainer();
- virtual void CleanContainers();
+ virtual void AddImagesToURContainer(VTKImageDataPointerType imgUndo,
+ VTKImageDataPointerType imgRedo, ImageMManager* imMManager);
+ virtual void CleanURContainerFromIndex(const int& index);
virtual void ManageMemory();
virtual ImageInfoUR* Undo();
virtual ImageInfoUR* Redo();
void ImageInfoUR::SetImageName(const StringType &imgName) {
this->m_ImageName = imgName;
}
+
void ImageInfoUR::SetImageMManager(ImageMManagerType* imMManager) {
this->m_ImageMManager = imMManager;
}
+
void ImageInfoUR::SetStatus(const bool& onMemory) {
this->m_OnMemory = onMemory;
}
-void ImageInfoUR::SetImage(VTKImageDataPointerType img) {
- this->m_Image = img;
- this->SetStatus(true);
-}
+
ImageInfoUR::StringType ImageInfoUR::GetImageName() {
return (this->m_ImageName);
}
-ImageInfoUR::VTKImageDataPointerType ImageInfoUR::GetImage() {
- return (this->m_Image);
+ImageInfoUR::VTKImageDataPointerType ImageInfoUR::GetUndoImage() {
+ return (this->m_UndoImage);
+}
+
+ImageInfoUR::VTKImageDataPointerType ImageInfoUR::GetRedoImage() {
+ return (this->m_RedoImage);
}
ImageInfoUR::ImageMManagerType* ImageInfoUR::GetImageMManager() {
return (this->m_ImageMManager);
}
+
bool ImageInfoUR::GetStatus() {
return (this->m_OnMemory);
}
-void ImageInfoUR::RemoveImageFromMemory(const StringType& gPath) {
- if (!this->m_OnDisk) {
- this->SaveImageAsMHD(gPath);
- }
- this->m_Image = NULL;
- this->SetStatus(false);
+
+void ImageInfoUR::SetImages(VTKImageDataPointerType imgUndo,
+ VTKImageDataPointerType imgRedo) {
+ this->m_UndoImage = imgUndo;
+ this->m_RedoImage = imgRedo;
+ this->SetStatus(true);
}
-void ImageInfoUR::LoadImageMHDToMemory(const StringType& gPath) {
+
+void ImageInfoUR::LoadImagesToMemory(const StringType& gPath) {
+ //setting paths
StringType filename = gPath + this->m_ImageName;
- filename.append(".mhd");
- VTKMetaImageReaderPointerType reader = VTKMetaImageReaderPointerType::New();
- reader->SetFileName(filename.c_str());
- this->m_Image = reader->GetOutput();
- this->m_Image->Update();
+ StringType undoImagePath = filename + "_Undo.mhd";
+ StringType redoImagePath = filename + "_Redo.mhd";
+ //Loading Undo Image
+ VTKMetaImageReaderPointerType readerUndo =
+ VTKMetaImageReaderPointerType::New();
+ readerUndo->SetFileName(undoImagePath.c_str());
+ this->m_UndoImage = readerUndo->GetOutput();
+ this->m_UndoImage->Update();
+ //Loading Redo Image
+ VTKMetaImageReaderPointerType readerRedo =
+ VTKMetaImageReaderPointerType::New();
+ readerRedo->SetFileName(redoImagePath.c_str());
+ this->m_RedoImage = readerRedo->GetOutput();
+ this->m_RedoImage->Update();
+ //Updating status
this->m_OnMemory = true;
}
-void ImageInfoUR::SaveImageAsMHD(const StringType& gPath) {
+
+void ImageInfoUR::RemoveImagesFromMemory(const StringType& gPath) {
+ if (!this->m_OnDisk) {
+ this->SaveImagesOnDisk(gPath);
+ }
+ this->m_UndoImage = NULL;
+ this->m_RedoImage = NULL;
+ this->SetStatus(false);
+}
+
+void ImageInfoUR::SaveImagesOnDisk(const StringType& gPath) {
this->m_OnDisk = true;
- StringType filename = gPath + this->m_ImageName;
- filename.append(".mhd");
//managing temporary files
//EED-11/11/2011 mkstemp((char*) filename.c_str());
+ StringType filename = gPath + this->m_ImageName;
+ StringType undoImagePath = filename + "_Undo.mhd";
+ StringType redoImagePath = filename + "_Redo.mhd";
+ this->SaveImageAsMHD(undoImagePath, this->m_UndoImage);
+ this->SaveImageAsMHD(redoImagePath, this->m_RedoImage);
+}
+
+void ImageInfoUR::RemoveImagesFromDisk(const StringType& gPath) {
+ StringType filename = gPath + this->m_ImageName;
+ StringType undoImagePathMHD = filename + "_Undo.mhd";
+ StringType redoImagePathMHD = filename + "_Redo.mhd";
+ StringType undoImagePathRAW = filename + "_Undo.raw";
+ StringType redoImagePathRAW = filename + "_Redo.raw";
+ //Unlink the files!!
+}
+
+void ImageInfoUR::SaveImageAsMHD(const StringType& filename,
+ VTKImageDataPointerType image) {
VTKMetaImageWriterPointerType w = VTKMetaImageWriterPointerType::New();
- w->SetInput(this->m_Image);
+ w->SetInput(image);
w->SetCompression(false);
- w->SetFileDimensionality(this->m_Image->GetDataDimension());
+ w->SetFileDimensionality(image->GetDataDimension());
w->SetFileName(filename.c_str());
w->Write();
}
-
-void ImageInfoUR::RemoveImageFromDisk(const StringType& gPath) {
- StringType filename = gPath + this->m_ImageName;
- filename.append(".mhd");
- StringType filenameRaw = gPath + this->m_ImageName;
- filenameRaw.append(".raw");
-//EED-11/11/2011 mkstemp((char*) filenameRaw.c_str());
- unlink((char*) filename.c_str());
- unlink((char*) filenameRaw.c_str());
-}
#include "regionStructUR.h"
#include "imageModificationManager.h"
+/*
+ * Tenga cuidado que siempre se va a referir a dos imagenes (UNDO/REDO) entonces de las dos imagenes es el mismo solo que
+ * finalizan distinto.
+ */
+
class ImageInfoUR {
public:
void SetImageName(const StringType &imgName);
void SetImageMManager(ImageMManagerType *imMManager);
void SetStatus(const bool& onMemory);
- void SetImage(VTKImageDataPointerType img);
- void RemoveImageFromMemory(const StringType& gPath);
- void LoadImageMHDToMemory(const StringType& gPath);
- void SaveImageAsMHD(const StringType& gPath);
- void RemoveImageFromDisk(const StringType& gPath);
- VTKImageDataPointerType GetImage();
+ void SetImages(VTKImageDataPointerType imgUndo,
+ VTKImageDataPointerType imgRedo);
+ void LoadImagesToMemory(const StringType& gPath);
+ void RemoveImagesFromMemory(const StringType& gPath);
+ void SaveImagesOnDisk(const StringType& gPath);
+ void RemoveImagesFromDisk(const StringType& gPath);
+ VTKImageDataPointerType GetUndoImage();
+ VTKImageDataPointerType GetRedoImage();
StringType GetImageName();
ImageMManagerType* GetImageMManager();
+ void SaveImageAsMHD(const StringType& filename,
+ VTKImageDataPointerType image);
bool GetStatus();
private:
- VTKImageDataPointerType m_Image;
+ VTKImageDataPointerType m_UndoImage;
+ VTKImageDataPointerType m_RedoImage;
StringType m_ImageName;
ImageMManagerType* m_ImageMManager;
bool m_OnMemory;
//virtual
void ImageUndoRedo::Undo() {
ImageInfoUR* imageInfo = this->m_ImagesDeque->Undo();
- if (imageInfo != NULL)
- {
+ if (imageInfo != NULL) {
//this->SetRedoImage(imageInfo->GetImageMManager());
- this->DrawUR(imageInfo);
+ this->DrawUR(imageInfo, true);
this->UpdateUndoImage();
}
}
//virtual
void ImageUndoRedo::Redo() {
/*ImageInfoUR* imageInfo = this->m_ImagesDeque->Redo();
- if (imageInfo != NULL)
- {
- this->DrawUR(imageInfo);
- }*/
+ if (imageInfo != NULL)
+ {
+ this->DrawUR(imageInfo);
+ }*/
}
void ImageUndoRedo::SetImage(VTKImageDataPointerType image) {
this->m_CurrentImage = image;
this->UpdateUndoImage();
}
//virtual
-void ImageUndoRedo::SetUndoImage(ImageMManagerType* imMManager) {
+void ImageUndoRedo::SetURImages(ImageMManagerType* imMManager) {
ImageMManagerType* newImageManager = new ImageMManagerType(imMManager);
if (newImageManager->ValidateRegion()) {
RegionSType region = newImageManager->GetModifiedRegion();
- VTKImageDataPointerType imgResult = this->GetImageRegion(region,
+ VTKImageDataPointerType imgUndo = this->GetImageRegion(region,
this->m_UndoImage);
- this->m_ImagesDeque->AddImageToUndoContainer(imgResult,
+ VTKImageDataPointerType imgRedo = this->GetImageRegion(region,
+ this->m_CurrentImage);
+ this->m_ImagesDeque->AddImagesToURContainer(imgUndo, imgRedo,
newImageManager);
this->UpdateUndoImage();
} else {
std::cerr << "INVALID REGION" << std::endl;
}
}
-//virtual
-void ImageUndoRedo::SetRedoImage(ImageMManagerType* imMManager) {
- /*this->m_CurrentImage->Update();
- ImageMManagerType* newImageManager = new ImageMManagerType(imMManager);
- if (newImageManager->ValidateRegion()) {
- RegionSType region = newImageManager->GetModifiedRegion();
- VTKImageDataPointerType imgResult = this->GetImageRegion(region,
- this->m_CurrentImage);
- this->m_ImagesDeque->AddImageToRedoContainer(imgResult,
- newImageManager);
- imgResult->Update();
- } else {
- std::cerr << "INVALID REGION" << std::endl;
- }*/
-}
void ImageUndoRedo::UpdateUndoImage() {
this->m_CurrentImage->Update();
this->m_CurrentImage = img;
}
//virtual
-void ImageUndoRedo::DrawUR(ImageInfoUR* imageInfo) {
- VTKImageDataPointerType img = imageInfo->GetImage();
+void ImageUndoRedo::DrawUR(ImageInfoUR* imageInfo, const bool& undo) {
+ VTKImageDataPointerType img;
+ if (undo) {
+ img = imageInfo->GetUndoImage();
+ } //fi
+ else {
+ img = imageInfo->GetRedoImage();
+ } //else
RegionSType region = imageInfo->GetImageMManager()->GetModifiedRegion();
if (img != NULL) {
for (int i = region.minX, x = 0; i <= region.maxX; i++, x++) {
virtual void Undo();
virtual void Redo();
virtual void SetImage(VTKImageDataPointerType image);
- virtual void SetUndoImage(ImageMManagerType* imMManager);
- virtual void SetRedoImage(ImageMManagerType* imMManager);
+ virtual void SetURImages(ImageMManagerType* imMManager);
void UpdateUndoImage();
void SetCurrentImage(VTKImageDataPointerType img);
VTKImageDataPointerType GetImageRegion(const RegionSType& region,
VTKImageDataPointerType img);
protected:
- virtual void DrawUR(ImageInfoUR* imageInfo);
+ virtual void DrawUR(ImageInfoUR* imageInfo, const bool& undo);
protected:
void ManagerUR::Redo() {
}
-void ManagerUR::SetUndoImage(ImageMManagerType* imMManager) {
+void ManagerUR::SetURImages(ImageMManagerType* imMManager) {
}
-void ManagerUR::SetRedoImage(ImageMManagerType* imMManager){
-}
-void ManagerUR::DrawUR(ImageInfoUR imageInfo) {
+void ManagerUR::DrawUR(ImageInfoUR imageInfo, const bool& undo) {
}
virtual void SetImage(vtkImageData *image);
virtual void Undo();
virtual void Redo();
- virtual void SetUndoImage(ImageMManagerType* imMManager);
- virtual void SetRedoImage(ImageMManagerType* imMManager);
+ virtual void SetURImages(ImageMManagerType* imMManager);
protected:
- virtual void DrawUR(ImageInfoUR imageInfo);
+ virtual void DrawUR(ImageInfoUR imageInfo, const bool& undo);
};
_tool = 0; // 0 pencil , 1 fill
_brushfilter = new BrushFilter();
_fillfilter = new FillFilter();
- _imageUndoRedo = new ImageUndoRedo();
+ //_imageUndoRedo = new ImageUndoRedo();
}
//---------------------------------------------------------------------------
void ManualPaintModel::SetImage(vtkImageData *image) {
_brushfilter->SetImage(image);
_fillfilter->SetImage(image);
- _imageUndoRedo->SetImage(image);
+ //_imageUndoRedo->SetImage(image);
}
//---------------------------------------------------------------------------
}
//---------------------------------------------------------------------------
void ManualPaintModel::SetUndoImage() {
- ImageMManager* imMManager = NULL;
- if (_tool == 0) {
- imMManager = this->_brushfilter->GetImageMManager();
- }
- if (_tool == 1) {
- imMManager = this->_fillfilter->GetImageMManager();
- }
- this->_imageUndoRedo->SetUndoImage(imMManager);
- this->_brushfilter->CleanImageMManager();
- this->_fillfilter->CleanImageMManager();
+ /*ImageMManager* imMManager = NULL;
+ if (_tool == 0) {
+ imMManager = this->_brushfilter->GetImageMManager();
+ }
+ if (_tool == 1) {
+ imMManager = this->_fillfilter->GetImageMManager();
+ }
+ this->_imageUndoRedo->SetURImages(imMManager);
+ this->_brushfilter->CleanImageMManager();
+ this->_fillfilter->CleanImageMManager();*/
}
//---------------------------------------------------------------------------
void ManualPaintModel::Undo() {
- this->_imageUndoRedo->Undo();
+ //this->_imageUndoRedo->Undo();
}
void ManualPaintModel::Redo() {
- this->_imageUndoRedo->Redo();
+ //this->_imageUndoRedo->Redo();
}
git://git.creatis.insa-lyon.fr / creaMaracasVisu.git / commitdiff