Added partial update pixel count.

nitko12 · nitko12 · commit 8ba09f8ec785 · 2021-09-27T11:22:06.000+02:00
diff --git a/src/Inkplate.h b/src/Inkplate.h
@@ -47,7 +47,7 @@ class Inkplate : public System, public Graphics
     void clearDisplay();
     void display(bool leaveOn = false);
     // void writeRow(uint8_t data);
-    void partialUpdate(bool _forced = false, bool leaveOn = false);
+    uint32_t partialUpdate(bool _forced = false, bool leaveOn = false);
 
 #ifdef ARDUINO_INKPLATECOLOR
     void clean();
diff --git a/src/boards/Inkplate10.cpp b/src/boards/Inkplate10.cpp
@@ -311,15 +311,17 @@ void IRAM_ATTR Inkplate::display3b(bool leaveOn)
  * deep sleep
  *
  * @note        Partial update only works in black and white mode
+ *
+ * @return      Number of pixels changed from black to white, leaving blur
  */
-void Inkplate::partialUpdate(bool _forced, bool leaveOn)
+uint32_t Inkplate::partialUpdate(bool _forced, bool leaveOn)
 {
     if (getDisplayMode() == 1)
-        return;
+        return 0;
     if (_blockPartial == 1 && !_forced)
     {
         display1b(leaveOn);
-        return;
+        return 0;
     }
 
     uint32_t _pos = (E_INK_WIDTH * E_INK_HEIGHT / 8) - 1;
@@ -328,12 +330,22 @@ void Inkplate::partialUpdate(bool _forced, bool leaveOn)
     uint8_t diffw, diffb;
     uint32_t n = (E_INK_WIDTH * E_INK_HEIGHT / 4) - 1;
 
+    uint32_t changeCount = 0;
+
     for (int i = 0; i < E_INK_HEIGHT; ++i)
     {
         for (int j = 0; j < E_INK_WIDTH / 8; ++j)
         {
             diffw = *(DMemoryNew + _pos) & ~*(_partial + _pos);
             diffb = ~*(DMemoryNew + _pos) & *(_partial + _pos);
+            if (diffw) // count pixels turning from black to white as these are visible blur
+            {
+                for (int bv = 1; bv < 256; bv <<= 1)
+                {
+                    if (diffw & bv)
+                        ++changeCount;
+                }
+            }
             _pos--;
             *(_pBuffer + n) = LUTW[diffw >> 4] & (LUTB[diffb >> 4]);
             n--;
@@ -346,7 +358,7 @@ void Inkplate::partialUpdate(bool _forced, bool leaveOn)
     {
         if (!einkOn())
         {
-            return;
+            return 0;
         }
     }
 
@@ -382,6 +394,8 @@ void Inkplate::partialUpdate(bool _forced, bool leaveOn)
         einkOff();
 
     memcpy(DMemoryNew, _partial, E_INK_WIDTH * E_INK_HEIGHT / 8);
+
+    return changeCount;
 }
 
 /**
diff --git a/src/boards/Inkplate5.cpp b/src/boards/Inkplate5.cpp
@@ -345,28 +345,40 @@ void IRAM_ATTR Inkplate::display3b(bool leaveOn)
  * deep sleep
  *
  * @note        Partial update only works in black and white mode
+ *
+ * @return      Number of pixels changed from black to white, leaving blur
  */
-void Inkplate::partialUpdate(bool _forced, bool leaveOn)
+uint32_t Inkplate::partialUpdate(bool _forced, bool leaveOn)
 {
     if (getDisplayMode() == 1)
-        return;
+        return 0;
 
     if (_blockPartial == 1 && !_forced)
     {
         display1b(leaveOn);
-        return;
+        return 0;
     }
     uint32_t _pos = (E_INK_WIDTH * E_INK_HEIGHT / 8) - 1;
     uint8_t data;
     uint8_t diffw, diffb;
     uint32_t n = (E_INK_WIDTH * E_INK_HEIGHT / 4) - 1;
 
-    for (int i = 0; i < E_INK_HEIGHT; i++)
+    uint32_t changeCount = 0;
+
+    for (int i = 0; i < E_INK_HEIGHT; ++i)
     {
-        for (int j = 0; j < E_INK_WIDTH / 8; j++)
+        for (int j = 0; j < E_INK_WIDTH / 8; ++j)
         {
-            diffw = ((*(DMemoryNew + _pos)) ^ (*(_partial + _pos))) & (~(*(_partial + _pos)));
-            diffb = ((*(DMemoryNew + _pos)) ^ (*(_partial + _pos))) & ((*(_partial + _pos)));
+            diffw = *(DMemoryNew + _pos) & ~*(_partial + _pos);
+            diffb = ~*(DMemoryNew + _pos) & *(_partial + _pos);
+            if (diffw) // count pixels turning from black to white as these are visible blur
+            {
+                for (int bv = 1; bv < 256; bv <<= 1)
+                {
+                    if (diffw & bv)
+                        ++changeCount;
+                }
+            }
             _pos--;
             *(_pBuffer + n) = LUTW[diffw >> 4] & (LUTB[diffb >> 4]);
             n--;
@@ -379,7 +391,7 @@ void Inkplate::partialUpdate(bool _forced, bool leaveOn)
     {
         if (!einkOn())
         {
-            return;
+            return 0;
         }
     }
 
@@ -416,6 +428,8 @@ void Inkplate::partialUpdate(bool _forced, bool leaveOn)
         *(DMemoryNew + i) &= *(_partial + i);
         *(DMemoryNew + i) |= (*(_partial + i));
     }
+
+    return changeCount;
 }
 
 /**
diff --git a/src/boards/Inkplate6.cpp b/src/boards/Inkplate6.cpp
@@ -361,16 +361,18 @@ void Inkplate::display3b(bool leaveOn)
  * deep sleep
  *
  * @note        Partial update only works in black and white mode
+ *
+ * @return      Number of pixels changed from black to white, leaving blur
  */
-void Inkplate::partialUpdate(bool _forced, bool leaveOn)
+uint32_t Inkplate::partialUpdate(bool _forced, bool leaveOn)
 {
     if (getDisplayMode() == 1)
-        return;
+        return 0;
 
     if (_blockPartial == 1 && !_forced)
     {
         display1b(leaveOn);
-        return;
+        return 0;
     }
 
     uint16_t _pos = (E_INK_WIDTH * E_INK_HEIGHT / 8) - 1;
@@ -379,12 +381,22 @@ void Inkplate::partialUpdate(bool _forced, bool leaveOn)
     uint8_t diffw, diffb;
     uint32_t n = (E_INK_WIDTH * E_INK_HEIGHT / 4) - 1;
 
+    uint32_t changeCount = 0;
+
     for (int i = 0; i < E_INK_HEIGHT; ++i)
     {
         for (int j = 0; j < E_INK_WIDTH / 8; ++j)
         {
             diffw = *(DMemoryNew + _pos) & ~*(_partial + _pos);
             diffb = ~*(DMemoryNew + _pos) & *(_partial + _pos);
+            if (diffw) // count pixels turning from black to white as these are visible blur
+            {
+                for (int bv = 1; bv < 256; bv <<= 1)
+                {
+                    if (diffw & bv)
+                        ++changeCount;
+                }
+            }
             _pos--;
             *(_pBuffer + n) = LUTW[diffw >> 4] & (LUTB[diffb >> 4]);
             n--;
@@ -397,7 +409,7 @@ void Inkplate::partialUpdate(bool _forced, bool leaveOn)
     {
         if (!einkOn())
         {
-            return;
+            return 0;
         }
     }
 
@@ -433,6 +445,8 @@ void Inkplate::partialUpdate(bool _forced, bool leaveOn)
         einkOff();
 
     memcpy(DMemoryNew, _partial, E_INK_WIDTH * E_INK_HEIGHT / 8);
+
+    return changeCount;
 }
 
 /**
diff --git a/src/boards/Inkplate6plus.cpp b/src/boards/Inkplate6plus.cpp
@@ -413,15 +413,17 @@ void Inkplate::display3b(bool leaveOn)
  * deep sleep
  *
  * @note        Partial update only works in black and white mode
+ *
+ * @return      Number of pixels changed from black to white, leaving blur
  */
-void Inkplate::partialUpdate(bool _forced, bool leaveOn)
+uint32_t Inkplate::partialUpdate(bool _forced, bool leaveOn)
 {
     if (getDisplayMode() == 1)
-        return;
+        return 0;
     if (_blockPartial == 1 && !_forced)
     {
         display1b(leaveOn);
-        return;
+        return 0;
     }
 
     uint32_t _pos = (E_INK_WIDTH * E_INK_HEIGHT / 8) - 1;
@@ -430,12 +432,22 @@ void Inkplate::partialUpdate(bool _forced, bool leaveOn)
     uint8_t diffw, diffb;
     uint32_t n = (E_INK_WIDTH * E_INK_HEIGHT / 4) - 1;
 
-    for (int i = 0; i < E_INK_HEIGHT; i++)
+    uint32_t changeCount = 0;
+
+    for (int i = 0; i < E_INK_HEIGHT; ++i)
     {
-        for (int j = 0; j < E_INK_WIDTH / 8; j++)
+        for (int j = 0; j < E_INK_WIDTH / 8; ++j)
         {
-            diffw = ((*(DMemoryNew + _pos)) ^ (*(_partial + _pos))) & (~(*(_partial + _pos)));
-            diffb = ((*(DMemoryNew + _pos)) ^ (*(_partial + _pos))) & ((*(_partial + _pos)));
+            diffw = *(DMemoryNew + _pos) & ~*(_partial + _pos);
+            diffb = ~*(DMemoryNew + _pos) & *(_partial + _pos);
+            if (diffw) // count pixels turning from black to white as these are visible blur
+            {
+                for (int bv = 1; bv < 256; bv <<= 1)
+                {
+                    if (diffw & bv)
+                        ++changeCount;
+                }
+            }
             _pos--;
             *(_pBuffer + n) = LUTW[diffw >> 4] & (LUTB[diffb >> 4]);
             n--;
@@ -448,7 +460,7 @@ void Inkplate::partialUpdate(bool _forced, bool leaveOn)
     {
         if (!einkOn())
         {
-            return;
+            return 0;
         }
     }
 
@@ -506,6 +518,8 @@ void Inkplate::partialUpdate(bool _forced, bool leaveOn)
     if (!leaveOn)
         einkOff();
     memcpy(DMemoryNew, _partial, E_INK_WIDTH * E_INK_HEIGHT / 8);
+
+    return changeCount;
 }
 
 #endif

Original file line number	Diff line number	Diff line change
`@@ -311,15 +311,17 @@ void IRAM_ATTR Inkplate::display3b(bool leaveOn)`
`311`	`311`	`* deep sleep`
`312`	`312`	`*`
`313`	`313`	`* @note Partial update only works in black and white mode`
	`314`	`+ *`
	`315`	`+ * @return Number of pixels changed from black to white, leaving blur`
`314`	`316`	`*/`
`315`		`-void Inkplate::partialUpdate(bool _forced, bool leaveOn)`
	`317`	`+uint32_t Inkplate::partialUpdate(bool _forced, bool leaveOn)`
`316`	`318`	`{`
`317`	`319`	`if (getDisplayMode() == 1)`
`318`		`- return;`
	`320`	`+ return 0;`
`319`	`321`	`if (_blockPartial == 1 && !_forced)`
`320`	`322`	`{`
`321`	`323`	`display1b(leaveOn);`
`322`		`- return;`
	`324`	`+ return 0;`
`323`	`325`	`}`
`324`	`326`
`325`	`327`	`uint32_t _pos = (E_INK_WIDTH * E_INK_HEIGHT / 8) - 1;`
`@@ -328,12 +330,22 @@ void Inkplate::partialUpdate(bool _forced, bool leaveOn)`
`328`	`330`	`uint8_t diffw, diffb;`
`329`	`331`	`uint32_t n = (E_INK_WIDTH * E_INK_HEIGHT / 4) - 1;`
`330`	`332`
	`333`	`+ uint32_t changeCount = 0;`
	`334`	`+`
`331`	`335`	`for (int i = 0; i < E_INK_HEIGHT; ++i)`
`332`	`336`	`{`
`333`	`337`	`for (int j = 0; j < E_INK_WIDTH / 8; ++j)`
`334`	`338`	`{`
`335`	`339`	`diffw = (DMemoryNew + _pos) & ~(_partial + _pos);`
`336`	`340`	`diffb = ~(DMemoryNew + _pos) & (_partial + _pos);`
	`341`	`+ if (diffw) // count pixels turning from black to white as these are visible blur`
	`342`	`+ {`
	`343`	`+ for (int bv = 1; bv < 256; bv <<= 1)`
	`344`	`+ {`
	`345`	`+ if (diffw & bv)`
	`346`	`+ ++changeCount;`
	`347`	`+ }`
	`348`	`+ }`
`337`	`349`	`_pos--;`
`338`	`350`	`*(_pBuffer + n) = LUTW[diffw >> 4] & (LUTB[diffb >> 4]);`
`339`	`351`	`n--;`
`@@ -346,7 +358,7 @@ void Inkplate::partialUpdate(bool _forced, bool leaveOn)`
`346`	`358`	`{`
`347`	`359`	`if (!einkOn())`
`348`	`360`	`{`
`349`		`- return;`
	`361`	`+ return 0;`
`350`	`362`	`}`
`351`	`363`	`}`
`352`	`364`
`@@ -382,6 +394,8 @@ void Inkplate::partialUpdate(bool _forced, bool leaveOn)`
`382`	`394`	`einkOff();`
`383`	`395`
`384`	`396`	`memcpy(DMemoryNew, _partial, E_INK_WIDTH * E_INK_HEIGHT / 8);`
	`397`	`+`
	`398`	`+ return changeCount;`
`385`	`399`	`}`
`386`	`400`
`387`	`401`	`/**`
Original file line number	Diff line number	Diff line change
`@@ -345,28 +345,40 @@ void IRAM_ATTR Inkplate::display3b(bool leaveOn)`
`345`	`345`	`* deep sleep`
`346`	`346`	`*`
`347`	`347`	`* @note Partial update only works in black and white mode`
	`348`	`+ *`
	`349`	`+ * @return Number of pixels changed from black to white, leaving blur`
`348`	`350`	`*/`
`349`		`-void Inkplate::partialUpdate(bool _forced, bool leaveOn)`
	`351`	`+uint32_t Inkplate::partialUpdate(bool _forced, bool leaveOn)`
`350`	`352`	`{`
`351`	`353`	`if (getDisplayMode() == 1)`
`352`		`- return;`
	`354`	`+ return 0;`
`353`	`355`
`354`	`356`	`if (_blockPartial == 1 && !_forced)`
`355`	`357`	`{`
`356`	`358`	`display1b(leaveOn);`
`357`		`- return;`
	`359`	`+ return 0;`
`358`	`360`	`}`
`359`	`361`	`uint32_t _pos = (E_INK_WIDTH * E_INK_HEIGHT / 8) - 1;`
`360`	`362`	`uint8_t data;`
`361`	`363`	`uint8_t diffw, diffb;`
`362`	`364`	`uint32_t n = (E_INK_WIDTH * E_INK_HEIGHT / 4) - 1;`
`363`	`365`
`364`		`- for (int i = 0; i < E_INK_HEIGHT; i++)`
	`366`	`+ uint32_t changeCount = 0;`
	`367`	`+`
	`368`	`+ for (int i = 0; i < E_INK_HEIGHT; ++i)`
`365`	`369`	`{`
`366`		`- for (int j = 0; j < E_INK_WIDTH / 8; j++)`
	`370`	`+ for (int j = 0; j < E_INK_WIDTH / 8; ++j)`
`367`	`371`	`{`
`368`		`- diffw = (((DMemoryNew + _pos)) ^ ((_partial + _pos))) & (~(*(_partial + _pos)));`
`369`		`- diffb = (((DMemoryNew + _pos)) ^ ((_partial + _pos))) & ((*(_partial + _pos)));`
	`372`	`+ diffw = (DMemoryNew + _pos) & ~(_partial + _pos);`
	`373`	`+ diffb = ~(DMemoryNew + _pos) & (_partial + _pos);`
	`374`	`+ if (diffw) // count pixels turning from black to white as these are visible blur`
	`375`	`+ {`
	`376`	`+ for (int bv = 1; bv < 256; bv <<= 1)`
	`377`	`+ {`
	`378`	`+ if (diffw & bv)`
	`379`	`+ ++changeCount;`
	`380`	`+ }`
	`381`	`+ }`
`370`	`382`	`_pos--;`
`371`	`383`	`*(_pBuffer + n) = LUTW[diffw >> 4] & (LUTB[diffb >> 4]);`
`372`	`384`	`n--;`
`@@ -379,7 +391,7 @@ void Inkplate::partialUpdate(bool _forced, bool leaveOn)`
`379`	`391`	`{`
`380`	`392`	`if (!einkOn())`
`381`	`393`	`{`
`382`		`- return;`
	`394`	`+ return 0;`
`383`	`395`	`}`
`384`	`396`	`}`
`385`	`397`
`@@ -416,6 +428,8 @@ void Inkplate::partialUpdate(bool _forced, bool leaveOn)`
`416`	`428`	`(DMemoryNew + i) &= (_partial + i);`
`417`	`429`	`(DMemoryNew + i) \|= ((_partial + i));`
`418`	`430`	`}`
	`431`	`+`
	`432`	`+ return changeCount;`
`419`	`433`	`}`
`420`	`434`
`421`	`435`	`/**`
Original file line number	Diff line number	Diff line change
`@@ -361,16 +361,18 @@ void Inkplate::display3b(bool leaveOn)`
`361`	`361`	`* deep sleep`
`362`	`362`	`*`
`363`	`363`	`* @note Partial update only works in black and white mode`
	`364`	`+ *`
	`365`	`+ * @return Number of pixels changed from black to white, leaving blur`
`364`	`366`	`*/`
`365`		`-void Inkplate::partialUpdate(bool _forced, bool leaveOn)`
	`367`	`+uint32_t Inkplate::partialUpdate(bool _forced, bool leaveOn)`
`366`	`368`	`{`
`367`	`369`	`if (getDisplayMode() == 1)`
`368`		`- return;`
	`370`	`+ return 0;`
`369`	`371`
`370`	`372`	`if (_blockPartial == 1 && !_forced)`
`371`	`373`	`{`
`372`	`374`	`display1b(leaveOn);`
`373`		`- return;`
	`375`	`+ return 0;`
`374`	`376`	`}`
`375`	`377`
`376`	`378`	`uint16_t _pos = (E_INK_WIDTH * E_INK_HEIGHT / 8) - 1;`
`@@ -379,12 +381,22 @@ void Inkplate::partialUpdate(bool _forced, bool leaveOn)`
`379`	`381`	`uint8_t diffw, diffb;`
`380`	`382`	`uint32_t n = (E_INK_WIDTH * E_INK_HEIGHT / 4) - 1;`
`381`	`383`
	`384`	`+ uint32_t changeCount = 0;`
	`385`	`+`
`382`	`386`	`for (int i = 0; i < E_INK_HEIGHT; ++i)`
`383`	`387`	`{`
`384`	`388`	`for (int j = 0; j < E_INK_WIDTH / 8; ++j)`
`385`	`389`	`{`
`386`	`390`	`diffw = (DMemoryNew + _pos) & ~(_partial + _pos);`
`387`	`391`	`diffb = ~(DMemoryNew + _pos) & (_partial + _pos);`
	`392`	`+ if (diffw) // count pixels turning from black to white as these are visible blur`
	`393`	`+ {`
	`394`	`+ for (int bv = 1; bv < 256; bv <<= 1)`
	`395`	`+ {`
	`396`	`+ if (diffw & bv)`
	`397`	`+ ++changeCount;`
	`398`	`+ }`
	`399`	`+ }`
`388`	`400`	`_pos--;`
`389`	`401`	`*(_pBuffer + n) = LUTW[diffw >> 4] & (LUTB[diffb >> 4]);`
`390`	`402`	`n--;`
`@@ -397,7 +409,7 @@ void Inkplate::partialUpdate(bool _forced, bool leaveOn)`
`397`	`409`	`{`
`398`	`410`	`if (!einkOn())`
`399`	`411`	`{`
`400`		`- return;`
	`412`	`+ return 0;`
`401`	`413`	`}`
`402`	`414`	`}`
`403`	`415`
`@@ -433,6 +445,8 @@ void Inkplate::partialUpdate(bool _forced, bool leaveOn)`
`433`	`445`	`einkOff();`
`434`	`446`
`435`	`447`	`memcpy(DMemoryNew, _partial, E_INK_WIDTH * E_INK_HEIGHT / 8);`
	`448`	`+`
	`449`	`+ return changeCount;`
`436`	`450`	`}`
`437`	`451`
`438`	`452`	`/**`
Original file line number	Diff line number	Diff line change
`@@ -413,15 +413,17 @@ void Inkplate::display3b(bool leaveOn)`
`413`	`413`	`* deep sleep`
`414`	`414`	`*`
`415`	`415`	`* @note Partial update only works in black and white mode`
	`416`	`+ *`
	`417`	`+ * @return Number of pixels changed from black to white, leaving blur`
`416`	`418`	`*/`
`417`		`-void Inkplate::partialUpdate(bool _forced, bool leaveOn)`
	`419`	`+uint32_t Inkplate::partialUpdate(bool _forced, bool leaveOn)`
`418`	`420`	`{`
`419`	`421`	`if (getDisplayMode() == 1)`
`420`		`- return;`
	`422`	`+ return 0;`
`421`	`423`	`if (_blockPartial == 1 && !_forced)`
`422`	`424`	`{`
`423`	`425`	`display1b(leaveOn);`
`424`		`- return;`
	`426`	`+ return 0;`
`425`	`427`	`}`
`426`	`428`
`427`	`429`	`uint32_t _pos = (E_INK_WIDTH * E_INK_HEIGHT / 8) - 1;`
`@@ -430,12 +432,22 @@ void Inkplate::partialUpdate(bool _forced, bool leaveOn)`
`430`	`432`	`uint8_t diffw, diffb;`
`431`	`433`	`uint32_t n = (E_INK_WIDTH * E_INK_HEIGHT / 4) - 1;`
`432`	`434`
`433`		`- for (int i = 0; i < E_INK_HEIGHT; i++)`
	`435`	`+ uint32_t changeCount = 0;`
	`436`	`+`
	`437`	`+ for (int i = 0; i < E_INK_HEIGHT; ++i)`
`434`	`438`	`{`
`435`		`- for (int j = 0; j < E_INK_WIDTH / 8; j++)`
	`439`	`+ for (int j = 0; j < E_INK_WIDTH / 8; ++j)`
`436`	`440`	`{`
`437`		`- diffw = (((DMemoryNew + _pos)) ^ ((_partial + _pos))) & (~(*(_partial + _pos)));`
`438`		`- diffb = (((DMemoryNew + _pos)) ^ ((_partial + _pos))) & ((*(_partial + _pos)));`
	`441`	`+ diffw = (DMemoryNew + _pos) & ~(_partial + _pos);`
	`442`	`+ diffb = ~(DMemoryNew + _pos) & (_partial + _pos);`
	`443`	`+ if (diffw) // count pixels turning from black to white as these are visible blur`
	`444`	`+ {`
	`445`	`+ for (int bv = 1; bv < 256; bv <<= 1)`
	`446`	`+ {`
	`447`	`+ if (diffw & bv)`
	`448`	`+ ++changeCount;`
	`449`	`+ }`
	`450`	`+ }`
`439`	`451`	`_pos--;`
`440`	`452`	`*(_pBuffer + n) = LUTW[diffw >> 4] & (LUTB[diffb >> 4]);`
`441`	`453`	`n--;`
`@@ -448,7 +460,7 @@ void Inkplate::partialUpdate(bool _forced, bool leaveOn)`
`448`	`460`	`{`
`449`	`461`	`if (!einkOn())`
`450`	`462`	`{`
`451`		`- return;`
	`463`	`+ return 0;`
`452`	`464`	`}`
`453`	`465`	`}`
`454`	`466`
`@@ -506,6 +518,8 @@ void Inkplate::partialUpdate(bool _forced, bool leaveOn)`
`506`	`518`	`if (!leaveOn)`
`507`	`519`	`einkOff();`
`508`	`520`	`memcpy(DMemoryNew, _partial, E_INK_WIDTH * E_INK_HEIGHT / 8);`
	`521`	`+`
	`522`	`+ return changeCount;`
`509`	`523`	`}`
`510`	`524`
`511`	`525`	`#endif`