{"id":195908,"date":"2025-01-13T08:52:43","date_gmt":"2025-01-13T08:52:43","guid":{"rendered":"https:\/\/innovationspace.ansys.com\/knowledge\/?post_type=topic&p=195908"},"modified":"2025-11-26T14:54:00","modified_gmt":"2025-11-26T14:54:00","slug":"image-processing-in-scade-one-with-the-pack-operator","status":"publish","type":"topic","link":"https:\/\/innovationspace.ansys.com\/knowledge\/forums\/topic\/image-processing-in-scade-one-with-the-pack-operator\/","title":{"rendered":"Image processing in Scade One with the pack operator"},"content":{"rendered":"

Introduction<\/h3>\n

In a previous blog series, we introduced Swan<\/a>, the domain-specific language designed for modeling in Scade One. We also explored how the forward<\/a> block facilitates the implementation of array and matrix operators with a new loop-like construct for iterative algorithms.<\/p>\n

In this new blog, we will showcase the pack operator, a powerful new construct available in Swan, that helps address common uses cases in signal processing such as correlation, convolution, cross-correlation, and more.<\/p>\n

The problem space<\/h3>\n

In today’s article, we will demonstrate how to to solve a signal processing problem with Scade One: detecting shapes in a noisy 2D image. To achieve this, we will implement a (somewhat naive) Scade One cross-correlation algorithm that demonstrates core principles.<\/p>\n

\n
\n <\/em>\n<\/p>\n

The solutions presented in this article can apply to any signal processing problem that looks at a signal’s current value and its neighbors. This includes many common applications: filtering, edge detection, blurring, sharpening, correlation, convolution, etc.<\/p>\n

A note on safe array access in Swan<\/h3>\n

One way to implement our algorithm would be to process our signal using a fixed-size, sliding window of elements.<\/p>\n

By construction, the Swan language enables safe usage of arrays<\/a>: arrays have a static size, no out-of-bounds accesses, and are fully defined. Any time we need to dynamically access an array index, we benefit from Scade One’s native array access protection. It returns a default value if the index is not within the array’s bounds:<\/p>\n

\n
\n <\/em>\n<\/p>\n

In some cases, the model designer may have already added a similar protection to the index computation itself. Such an approach may introduce uncoverable points in the model, that may later need to be justified during validation.<\/p>\n

One thing to note is that the above construct introduces an if<\/code> statement in the generated C code. Signal processing algorithms often involve processing large arrays and reading several contiguous values. Relying on the above construct for such a large number of reads would be detrimental to performance; we are therefore going to rely on another construct that fits our purpose better.<\/p>\n

Introducing the pack block<\/h3>\n

In the Swan language, successor of Scade, the new pack block<\/strong> allows us to process a Swan array or matrix by chunks, which may or may not overlap<\/strong>.<\/p>\n

The pack<\/strong> operator guarantees safe and efficient<\/em> usage of arrays without the need to specify redundant default values.<\/p>\n

Swan language reference<\/strong><\/p>\n\n\n
\n

pack<‍<‍k,m‍>‍>(A)<\/code> returns the array composed of m<\/code> chunks of size k<\/code>; chunks can overlap.<\/p>\n

If A<\/code> is of size n<\/code>, B = pack<‍<‍k,m‍>‍>(A)<\/code> is such that B[i][j] = A[s*i*j]<\/code> where s = (n-k)\/(m-1)<\/code><\/p>\n

    \n
  • input<\/code>: an array of type T^n<\/code><\/li>\n
  • input parameters: <\/em>k<\/code>, <\/em>m<\/code> <\/em>two sizes verifying the conditions: m‍>1<\/code> and k<‍n<\/code> and (m-1)<\/code> divides (n-k)<\/code><\/li>\n
  • output: an array of type T^k^m<\/code><\/li>\n<\/ul>\n<\/td>\n<\/tr>\n<\/table>\n

    Examples:<\/p>\n

    Let’s have a look at four use cases, starting from this stream of values:<\/p>\n

    \n
    \n <\/em>\n<\/p>\n

    We want to apply an iterative algorithm on:<\/p>\n

      \n
    • 4 chunks with size 5 without overlap between each chunk.<\/li>\n<\/ul>\n\n\n
      \n

      n = 20<\/code>, size of the stream <\/p>\n

      k = 5<\/code>, size of each chunk<\/p>\n

      s = 5<\/code>, to avoid overlap<\/p>\n

      Let’s verify constraints: s = (n - k) \/ (m - 1)<\/code><\/p>\n

      or : m = (n - k) \/ s + 1<\/code><\/p>\n

        \n
      • pack<‍<‍5 , (20 - 5) \/ 4 + 1‍>‍><\/code><\/li>\n
      • pack<‍<‍5,4‍>‍><\/code><\/li>\n<\/ul>\n

        \n
        \n <\/em>\n<\/p>\n

        pack<‍<‍5,4‍>‍>(A)<\/code> reshapes A<\/code> from integer^20<\/code> to integer^5^4<\/code><\/p>\n<\/td>\n<\/tr>\n<\/table>\n

          \n
        • Overlapping chunks with size 5, shifted by 1.<\/li>\n<\/ul>\n\n\n
          \n

          n = 20<\/code>, size of the stream <\/p>\n

          k = 5<\/code>, size of each chunk<\/p>\n

          s = 1<\/code><\/p>\n

          Let’s verify constraints: s = (n - k) \/ (m - 1)<\/code><\/p>\n

          or : m = (n - k) \/ s + 1<\/code><\/p>\n

            \n
          • pack<‍<‍5 , (20 - 5) \/ 1 + 1‍>‍><\/code><\/li>\n
          • pack<‍<‍5,16‍>‍><\/code><\/li>\n<\/ul>\n

            \n
            \n <\/em>\n<\/p>\n

            pack<‍<‍5,16‍>‍>(A)<\/code> reshapes A<\/code> from integer^20<\/code> to integer^5^16<\/code><\/p>\n<\/td>\n<\/tr>\n<\/table>\n

              \n
            • Overlapping chunks with size 5, shifted by 2.<\/li>\n<\/ul>\n\n\n
              \n

              n = 20<\/code>, the size of the stream <\/p>\n

              k = 5<\/code>, the size of chunk<\/p>\n

              s = 2<\/code><\/p>\n

              Let’s verify constraint: s = (n - k) \/ (m - 1)<\/code><\/p>\n

              or : m = (n - k) \/ s + 1<\/code><\/p>\n

              The result has no integer solution<\/strong>: (m-1)<\/code> does not divide (n-k)<\/code>.<\/p>\n

              We need to add or crop values to or from the input stream to shift by 2 with pack<\/p>\n

                \n
              • pack<‍<‍5,9‍>‍>(A @ [A[19]])<\/code> <\/em>reshapes A from integer^21<\/code> to integer^5^9<\/code><\/li>\n<\/ul>\n

                \n
                \n <\/em>\n<\/p>\n<\/td>\n<\/tr>\n<\/table>\n

                Using pack in one dimension<\/h3>\n

                A common signal processing need is to apply an operation, such as ⊗, ⊕, *, or any user algorithm<\/em> between a sliding mask<\/em> and a stream<\/em> values:<\/p>\n

                \n
                \n <\/em>\n<\/p>\n

                Step 1, we reshape stream A<\/code> by using pack<\/code>, as explained above, to propose a way to iterate safely with a forward<\/code> <\/em>loop. <\/p>\n

                With N = 20<\/code> and K = 5<\/code><\/p>\n

                \n
                \n
                \n <\/em>\n<\/p>\n

                Step 2, we apply our algorithm on each element of the chunk. Let’s cumulate the square of the difference between chunk and mask elements:<\/p>\n

                \n
                \n <\/em>\n<\/p>\n

                And finally, we fill in our algorithm to compute the difference of squares:<\/p>\n

                \n
                \n <\/em>\n<\/p>\n

                The resulting array of this operation is an array of size N-k+1<\/code>.<\/p>\n

                For consistency, let’s complete the output array by appending (@<\/code> operator) the end value to retrieve the same input size.<\/p>\n

                \n
                \n <\/em>\n<\/p>\n

                The resulting stream is the following. It measures, at each position, the gap between the mask and the input stream. The minimum value corresponds to the best match (least difference). A result of 0 corresponds to the perfect match (no difference).<\/p>\n

                \n
                \n <\/em>\n<\/p>\n

                Running a test in our Scade One model, we confirm that the above example finds a perfect match at index 7:<\/p>\n

                \n
                \n <\/em>\n<\/p>\n

                Using pack in two dimensions<\/h3>\n

                Let’s go back to our initial problem: detecting shapes in a 2D image. For this, we will use pack<\/code> in two dimensions.<\/p>\n

                Here, the stream becomes a picture, implemented as a two-dimension matrix of type integer^COL^ROW<\/code>.<\/em><\/p>\n

                The mask is a small square shape, implemented as a two-dimension matrix of type integer^K^K<\/code>.<\/p>\n

                We must now determine the position of the mask shape in the picture:<\/p>\n

                \n
                \n <\/em>\n<\/p>\n

                Our aim is to visit all parts of the image with the same size as the mask and apply our algorithm on each one.<\/p>\n

                The picture has type integer^Col^Row<\/code> and the mask has type integer^K^K<\/code>.<\/p>\n

                We start by creating a pack of K<\/code> rows, shifted by one row:<\/p>\n

                \n
                \n <\/em>\n<\/p>\n

                pack <‍<‍K, Row-K+1‍>‍>(picture)<\/code> \u2192 integer^Col^K^(Row-K+1)<\/code><\/p>\n

                Then, we iterate on each pack:<\/p>\n

                <\/p>\n

                \n
                <\/span>forward<\/span> &lt;&zwj;&lt;&zwj;Row-<\/span>k+<\/span>1<\/span>&zwj;&gt;&zwj;&gt; with<\/span> [lines] =<\/span> pack<\/span>&lt;&zwj;&lt;&zwj;K,Row-<\/span>K+<\/span>1<\/span>&zwj;&gt;&zwj;&gt;(picture);\r\n<\/pre>\n<\/div>\n
                \n    
                \n    <\/em>\n<\/p>\n
                Now, we want to create a pack of K<\/code> columns from lines \u2192<\/em> integer^Col^K<\/code>:<\/p>\n
                \n    
                \n    <\/em>\n<\/p>\n
                To iterate on the second dimension Col, we must transpose the dimension: transpose(rows)<\/code> \u2192<\/em> integer^K^Col<\/code><\/p>\n
                When applying pack on transpose(rows)<\/code>:<\/p>\n
                <\/p>\n
                \n
                <\/span>pack<\/span> &lt;&zwj;&lt;&zwj;K, Col-<\/span>K+<\/span>1<\/span>&zwj;&gt;&zwj;&gt;(transpose<\/span>(rows)) \u2192 integer<\/span>^<\/span>K^<\/span>K^<\/span>(Col-<\/span>k+<\/span>1<\/span>)\r\n<\/pre>\n<\/div>\n
                Our final form is:<\/p>\n
                <\/p>\n
                \n
                <\/span>forward<\/span> &lt;&zwj;&lt;&zwj;Col-<\/span>k+<\/span>1<\/span>&zwj;&gt;&zwj;&gt; with<\/span> [subrows] =<\/span> pack<\/span>&lt;&zwj;&lt;&zwj;K,Col-<\/span>K+<\/span>1<\/span>&zwj;&gt;&zwj;&gt;(transpose<\/span>(rows));\r\n<\/pre>\n<\/div>\n
                \n    
                \n    <\/em>\n<\/p>\n
                We are now able to iterate on mask-sized subpictures, computing the difference between our mask and each subpicture.<\/p>\n
                Notice that here we use a square mask, and the dimensions seem good between the mask and the subpicture. All are matrices of type \u2192<\/em> integer ^K^K<\/code>.<\/p>\n
                However, due to the previous transpose<\/code> operation, mask dimensions are reversed; we must transpose our subpicture to realign it with the mask:<\/p>\n
                \n    
                \n    <\/em>\n<\/p>\n
                <\/p>\n
                \n
                <\/span>forward<\/span>\r\n&lt;&zwj;&lt;&zwj;K&zwj;&gt;&zwj;&gt;\r\n&lt;&zwj;&lt;&zwj;K&zwj;&gt;&zwj;&gt; with<\/span> [[s]]=<\/span>shape; [[elt]]=transpose<\/span>(subrows);\r\n<\/pre>\n<\/div>\n
                Here is our final operator:<\/p>\n
                \n    
                \n    <\/em>\n<\/p>\n
                The resulting matrix measures, at each position, the difference between the mask and the input picture. The minimum value corresponds to the best match.<\/p>\n
                A naive approach to find this best match consists in extracting the position of the minimum value, cumulatively measured for each line and column.<\/p>\n
                \n    
                \n    
                \n    <\/em>\n<\/p>\n
                Now that our implementation is complete, here is a video of our Scade One model in action, with a graphical panel showing what’s happening:<\/p>\n