void MemoryManager<AllocatorType>::deallocate(Byte* address)
{
if(address == nullptr)
return;
// Find the block corresponding to the address
size_t index{0};
typename BlockList::iterator it;
while(index < _addressSize)
{
it = findBlock(_allocatedBlocks[index], address, index);
if(it != _allocatedBlocks[index].end())
break;
index++;
}
if(it != _allocatedBlocks[index].end())
{
// Add the freed block to the free list
_allocatedBlocks[index].erase(it);
_freeBlocks[index].pushFront(address);
tryMerge(_freeBlocks[index].begin(), index);
}
else
out << "Error: MemoryMamanger::deallocate: invalid pointer argument (" << address << ")\n";
if(_activateMemoryDump)
memoryDump();
}
void MemoryManager<AllocatorType>::tryMerge(typename BlockList::iterator blockToMergeIt, size_t index)
{
const size_t blockSize{1UL << index};
for(typename BlockList::iterator it{_freeBlocks[index].begin()}; it != _freeBlocks[index].end(); ++it)
{
// If we found a block...
if(it != blockToMergeIt
// that is adjacent to the block to merge...
and static_cast<size_t>(abs(*it - *blockToMergeIt)) == blockSize
// and that has a size corresponding to index
and findBlock(_freeBlocks[index], *it, index) != _freeBlocks[index].end())
{
typename BlockList::iterator lowerBlockIt{*it < *blockToMergeIt ? it : blockToMergeIt};
typename BlockList::iterator upperBlockIt{lowerBlockIt == blockToMergeIt ? it : blockToMergeIt};
Byte* baseAddress{*lowerBlockIt};
_freeBlocks[index].erase(lowerBlockIt);
_freeBlocks[index].erase(upperBlockIt);
_freeBlocks[index + 1].pushFront(baseAddress);
// Recursively merge bigger blocks
tryMerge(_freeBlocks[index + 1].begin(), index + 1);
break;
}
}
}
bool MergeInfillLines::mergeInfillLines(std::vector<GCodePath>& paths, const Point& starting_position) const
{
/* Algorithm overview:
1. Loop over all lines to see if they can be merged.
1a. Check if two adjacent lines can be merged (skipping travel moves in
between).
1b. If they can, merge both lines into the first line.
1c. If they are merged, check next that the first line can be merged
with the line after the second line.
2. Do a second iteration over all paths to remove the tombstones. */
std::vector<size_t> remove_path_indices;
std::set<size_t> is_merged;
std::set<size_t> removed; // keep track of what we already removed, so don't remove it again
//For each two adjacent lines, see if they can be merged.
size_t first_path_index = 0;
Point first_path_start = Point(starting_position.X, starting_position.Y); // this one is not going to be overwritten
size_t second_path_index = 1;
coord_t error_area = 0;
for (; second_path_index < paths.size(); second_path_index++)
{
GCodePath& first_path = paths[first_path_index];
GCodePath& second_path = paths[second_path_index];
Point second_path_start = paths[second_path_index - 1].points.back();
if (second_path.config->isTravelPath())
{
continue; //Skip travel paths, we're looking for the first non-travel path.
}
bool allow_try_merge = true;
// see if we meet criteria to merge. should be: travel - path1 not travel - (...) - travel - path2 not travel - travel
// we're checking the travels here
if (first_path_index <= 1 || !paths[first_path_index - 1].isTravelPath()) // "<= 1" because we don't want the first travel being changed. That may introduce a hole somewhere
{
allow_try_merge = false;
}
if (second_path_index + 1 >= paths.size() || !paths[second_path_index + 1].isTravelPath())
{
allow_try_merge = false;
}
if (first_path.config->isTravelPath()) //Don't merge travel moves.
{
allow_try_merge = false;
}
if (first_path.config != second_path.config) //Only merge lines that have the same type.
{
allow_try_merge = false;
}
if (first_path.config->type != PrintFeatureType::Infill && first_path.config->type != PrintFeatureType::Skin) //Only merge skin and infill lines.
{
allow_try_merge = false;
}
const bool first_is_already_merged = is_merged.find(first_path_index) != is_merged.end();
if ((!first_is_already_merged && first_path.points.size() > 1) || second_path.points.size() > 1)
{
// For now we only merge simple lines, not polylines, to keep it simple.
// If the first line is already a merged line, then allow it.
allow_try_merge = false;
}
Point new_first_path_start;
if (allow_try_merge && tryMerge(first_is_already_merged, first_path, first_path_start, second_path, second_path_start, new_first_path_start, error_area))
{
if (!first_is_already_merged)
{
paths[first_path_index - 1].points.back().X = new_first_path_start.X;
paths[first_path_index - 1].points.back().Y = new_first_path_start.Y;
}
/* If we combine two lines, the next path may also be merged into the fist line, so we do NOT update
first_path_index. */
for (size_t to_delete_index = first_path_index + 1; to_delete_index <= second_path_index; to_delete_index++)
{
if (removed.find(to_delete_index) == removed.end()) // if there are line(s) between first and second, then those lines are already marked as to be deleted, only add the new line(s)
{
remove_path_indices.push_back(to_delete_index);
removed.insert(to_delete_index);
}
}
is_merged.insert(first_path_index);
}
else
{
/* If we do not combine, the next iteration we must simply merge the
second path with the line after it. */
first_path_index = second_path_index;
first_path_start = second_path_start;
}
}
//Delete all removed lines in one pass so that we need to move lines less often.
if (!remove_path_indices.empty())
{
size_t path_index = remove_path_indices[0];
for (size_t removed_position = 1; removed_position < remove_path_indices.size(); removed_position++)
{
for (; path_index < remove_path_indices[removed_position] - removed_position; path_index++)
{
paths[path_index] = paths[path_index + removed_position]; //Shift all paths.
}
}
for (; path_index < paths.size() - remove_path_indices.size(); path_index++) //Remaining shifts at the end.
{
paths[path_index] = paths[path_index + remove_path_indices.size()];
}
paths.erase(paths.begin() + path_index, paths.end());
return true;
}
else
{
return false;
}
}
bool MergeInfillLines::mergeInfillLines(std::vector<GCodePath>& paths, const Point& starting_position) const
{
/* Algorithm overview:
1. Loop over all lines to see if they can be merged.
1a. Check if two adjacent lines can be merged (skipping travel moves in
between).
1b. If they can, merge both lines into the first line.
1c. If they are merged, check next that the first line can be merged
with the line after the second line.
2. Do a second iteration over all paths to remove the tombstones. */
std::vector<size_t> remove_path_indices;
std::set<size_t> is_merged;
std::set<size_t> removed; // keep track of what we already removed, so don't remove it again
//For each two adjacent lines, see if they can be merged.
size_t first_path_index = 0;
Point first_path_start = Point(starting_position.X, starting_position.Y); // this one is not going to be overwritten
size_t second_path_index = 1;
bool has_first_path = paths.empty() ? false : !paths[0].config->isTravelPath(); // in case the first path is not an extrusion path.
coord_t error_area = 0;
for (; second_path_index < paths.size(); second_path_index++)
{
GCodePath& first_path = paths[first_path_index];
GCodePath& second_path = paths[second_path_index];
Point second_path_start = paths[second_path_index - 1].points.back();
if (second_path.config->isTravelPath())
{
has_first_path = false;
continue; //Skip travel paths, we're looking for the first non-travel path.
}
// FIXME: This is difficult to fix, need to put extra effort into it.
// CURA-5776: This works in some cases but it is not exactly correct, because what this will avoid merging
// lines are kind like in parallel but with a travel move in between, which is a case mergeLinesSideBySide()
// tries to handle. We found that something can go wrong when it tries to merge some pattern like those
// parallel lines, and we think that the current merging method is not suitable for that. In short, we
// probably need treat different patterns with different methods.
//
// Use the first non-travel path as the first path that can be used for merging. After we encounter
// a travel path, we need to find another first non-travel path for merging.
if (
(
first_path.config->type == PrintFeatureType::Infill ||
first_path.config->type == PrintFeatureType::SupportInfill ||
first_path.skip_agressive_merge_hint
) && !has_first_path)
{
first_path_index = second_path_index;
first_path_start = second_path_start;
has_first_path = true;
continue;
}
bool allow_try_merge = true;
// see if we meet criteria to merge. should be: travel - path1 not travel - (...) - travel - path2 not travel - travel
// we're checking the travels here
if (first_path_index <= 1 || !paths[first_path_index - 1].isTravelPath()) // "<= 1" because we don't want the first travel being changed. That may introduce a hole somewhere
{
allow_try_merge = false;
}
if (second_path_index + 1 >= paths.size() || !paths[second_path_index + 1].isTravelPath())
{
allow_try_merge = false;
}
if (first_path.config->isTravelPath()) //Don't merge travel moves.
{
allow_try_merge = false;
}
if (first_path.config != second_path.config) //Only merge lines that have the same type.
{
allow_try_merge = false;
}
if (first_path.config->type != PrintFeatureType::Infill && first_path.config->type != PrintFeatureType::Skin) //Only merge skin and infill lines.
{
allow_try_merge = false;
}
const bool first_is_already_merged = is_merged.find(first_path_index) != is_merged.end();
if ((!first_is_already_merged && first_path.points.size() > 1) || second_path.points.size() > 1)
{
// For now we only merge simple lines, not polylines, to keep it simple.
// If the first line is already a merged line, then allow it.
allow_try_merge = false;
}
Point new_first_path_start;
if (allow_try_merge && tryMerge(first_is_already_merged, first_path, first_path_start, second_path, second_path_start, new_first_path_start, error_area))
{
if (!first_is_already_merged)
{
paths[first_path_index - 1].points.back().X = new_first_path_start.X;
paths[first_path_index - 1].points.back().Y = new_first_path_start.Y;
}
/* If we combine two lines, the next path may also be merged into the fist line, so we do NOT update
first_path_index. */
for (size_t to_delete_index = first_path_index + 1; to_delete_index <= second_path_index; to_delete_index++)
{
if (removed.find(to_delete_index) == removed.end()) // if there are line(s) between first and second, then those lines are already marked as to be deleted, only add the new line(s)
{
remove_path_indices.push_back(to_delete_index);
removed.insert(to_delete_index);
}
}
is_merged.insert(first_path_index);
}
else
{
/* If we do not combine, the next iteration we must simply merge the
second path with the line after it. */
first_path_index = second_path_index;
first_path_start = second_path_start;
}
}
//Delete all removed lines in one pass so that we need to move lines less often.
if (!remove_path_indices.empty())
{
size_t path_index = remove_path_indices[0];
for (size_t removed_position = 1; removed_position < remove_path_indices.size(); removed_position++)
{
for (; path_index < remove_path_indices[removed_position] - removed_position; path_index++)
{
paths[path_index] = paths[path_index + removed_position]; //Shift all paths.
}
}
for (; path_index < paths.size() - remove_path_indices.size(); path_index++) //Remaining shifts at the end.
{
paths[path_index] = paths[path_index + remove_path_indices.size()];
}
paths.erase(paths.begin() + path_index, paths.end());
return true;
}
else
{
return false;
}
}
